检查两个数组是否具有相同成员的最佳方法

知识点掌握了，还需要不断练习才能熟练运用。下面golang学习网给大家带来一个Golang开发实战，手把手教大家学习《检查两个数组是否具有相同成员的最佳方法》，在实现功能的过程中也带大家重新温习相关知识点，温故而知新，回头看看说不定又有不一样的感悟！

我有一个字符串数组，我需要将其与另一个字符串数组进行比较，但它们的顺序可能不同。比较两个数组的最佳方法是什么？

这就是我到目前为止所拥有的，只是想知道我是否缺少一种更简单/更有效的方法。

func unorderedEqual(first, second []string) bool {
    if len(first) != len(second) {
        return false
    }
    for _, value := range first {
        if !contains(value, second) {
            return false
        }
    }
    return true
}

func contains(needle string, haystack []string) bool {
    for _, matchValue := range haystack {
        if matchValue == needle {
            return true
        }
    }
    return false
}

解决方案

鉴于您正在进行长度检查，我将采用暗示它们是 1:1 的假设，只是顺序不同。

您可以使用 map[string]bool 一次完成此操作（每次）来检查两者是否存在。这利用了以下事实：当密钥不存在时，map 返回 bool 的零值，即 false。

免责声明：从技术上讲，这是 o(n)*o(map) 的顺序。 Go Programming Language Specification不对地图类型做任何性能保证。

https://play.golang.org/p/2LUjN5LkXLL

func unorderedequal(first, second []string) bool {
    if len(first) != len(second) {
        return false
    }
    exists := make(map[string]bool)
    for _, value := range first {
        exists[value] = true
    }
    for _, value := range second {
        if !exists[value] {
            return false
        }
    }
    return true
}

如果你想对内存使用挑剔，你可以通过使用 map[string]struct{} （空的struct），您只需稍微不同地检查是否存在，如本例所示。

https://play.golang.org/p/MjwP_wCtYZV

设置

exists[value] = struct{}{}

检查

if _, ok := exists[value]; !ok {
    return false
}

理想情况下，这应该是一条注释，但总而言之，使用 husain 的排序和比较会更正确、更快。

详细信息。 对于任何查看上面 rayfenwindspear 答案（目前排名最高）的人来说，乍一看它看起来是正确的，但请注意它不会检查完全相等性，而只是检查第二个列表中的每个元素都在第一个列表中。反之亦然，但此方法不检查。因此它未通过此测试（重复 bb）。：

assert.false(t, unorderedequal([]string{"aa", "cc", "bb"}, []string{"aa", "bb", "bb"}))

当然你可以运行两次就得到正确的结果，这只是一个线性因子

func doubleunorderedequal(a, b []string) bool {
    return unorderedequal(a, b) && unorderedequal(b, a)
}

husain 对排序然后检查的建议可能应该排名更高，因为它是正确的，并且对于较大的列表也更快。

这是 husain 在导出函数中的代码：

func sortcompare(a, b []string) bool {
    if len(a) != len(b) {
        return false
    }

    sort.strings(a)
    sort.strings(b)

    for i, v := range a {
        if v != b[i] {
            return false
        }
    }
    return true
}

您可以在其上运行一些测试（它通过了）

func testsortcompare(t *testing.t) {

    assert.true(t, sortcompare([]string{"aa"}, []string{"aa"}))
    assert.false(t, sortcompare([]string{"aa"}, []string{"bb"}))
    assert.false(t, sortcompare([]string{"aa"}, []string{"bb", "cc"}))
    assert.true(t, sortcompare([]string{"cc", "bb"}, []string{"bb", "cc"}))
    assert.true(t, sortcompare([]string{"aa", "cc", "bb"}, []string{"aa", "bb", "cc"}))
    assert.false(t, sortcompare([]string{"aa", "cc", "bb"}, []string{"aa", "bb", "bb"}))
}

这是一些基准测试示例......

func getstrings() ([]string, []string) {

    a := []string{"a", "foo", "bar", "ping", "pong"}
    b := []string{"pong", "foo", "a", "bar", "ping"}

    return a, b

}

func benchmarksortcompare(b *testing.b) {
    s0, s1 := getstrings()
    var outcome bool
    for n := 0; n < b.n; n++ {
        outcome = sortcompare(s0, s1)
    }
    fmt.println(outcome)
}

func benchmarkdoubleunorderedequal(b *testing.b) {
    s0, s1 := getstrings()
    var outcome bool
    for n := 0; n < b.n; n++ {
        outcome = doubleunorderedequal(s0, s1)
    }
    fmt.println(outcome)
}

结果...

benchmarksortcompare-32                  2637952           498 ns/op
benchmarkdoubleunorderedequal-32         3060261           381 ns/op

所以在这么小的尺寸下，运行两次map方法会稍微快一些...但是添加更多的字符串，排序方法会以10倍的优势获胜。我没有考虑无序程度的影响乍一看，这并不是一个明显不公平的测试。

func getstrings2() ([]string, []string) {

    a := []string{"a", "foo", "bar", "ping", "pong", "b", "c", "g", "e", "f", "d", "h", "i", "j", "q", "l", "n", "o", "p", "k", "r", "s", "t", "u", "v", "w", "x", "y", "z"}
    b := []string{"pong", "foo", "a", "bar", "ping", "p", "r", "q", "s", "u", "t", "v", "j", "x", "y", "z", "b", "e", "d", "c", "h", "g", "f", "i", "w", "k", "l", "n", "o"}

    return a, b

}

func benchmarksortcompare2(b *testing.b) {
    s0, s1 := getstrings2()
    var outcome bool
    for n := 0; n < b.n; n++ {
        outcome = sortcompare(s0, s1)
    }
    fmt.println(outcome)
}

func benchmarkdoubleunorderedequal2(b *testing.b) {
    s0, s1 := getstrings2()
    var outcome bool
    for n := 0; n < b.n; n++ {
        outcome = doubleunorderedequal(s0, s1)
    }
    fmt.println(outcome)
}

结果：

BenchmarkSortCompare2-32                  454641          2797 ns/op
BenchmarkDoubleUnorderedEqual2-32          44420         26714 ns/op

结论 - 我将使用 husain 的排序和比较......

今天带大家了解了的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~