如何确定两个乱序长字符串数组是否完全相等？答案

【问题标题】：How to determine if the two out-of-order long-strings arrays are exactly equal?如何确定两个乱序长字符串数组是否完全相等？
【发布时间】：2018-03-19 15:51:40
【问题描述】：

有两个乱序字符串数组，其中包含多个可能重复的非常长的字符串。如何判断两个数组是否完全相等？

例子：

[“abc”, "abc", "bcd", "efg"] ==  ["bcd", "efg", “abc”, "abc"]

我能想到的最简单的方法是排序后比较两个数组。

但是当数组中的每个字符串都很长时，每次进行字符串比较是很耗时的。有什么办法可以改善吗？

 let array1 = ["aaa...(100 a)...aa", "bbb...(100 b)... bbb", "ccc...(100c) ...c", ....]
 let array2 = ["bbb...(100 b)... bbb", "aaa...(100 a)...aa", "ccc...(100c) ...c", ....]

可以使用任何语言求解，但不能使用库中的函数直接比较数组是否相等。

【问题讨论】：

您尝试使用哪种语言？
在数组迭代期间创建一个Counter() 对象并比较它们。通常，这是每个单词及其相关出现计数的哈希值。将在 O(n) 时间和空间内工作。
C/C++或Java，最好不要使用语言内置的数组比较函数。
对不起，我在 Javascript 中发布了我的答案，我看到你的消息晚了，但 Java 中的逻辑也将保持不变
请给问题相关的语言标签。如果需要扔掉algorithm + sorting，反正这些都没用。

标签： arrays string algorithm sorting

【解决方案1】：

如果在 Python 中：

import collections
def areItersEqual(a1, a2):    
    return collections.Counter(a1) == collections.Counter(a2)

>>> a1 = [“abc”, "abc", "bcd", "efg"] 
>>> a2 = ["bcd", "efg", “abc”, "abc"] 
>>> assert areItersEqual(a1,a2) is True
True

这样，时间和空间的上限是 O(m+n)，而不是 O(n logn) + O(m logm) 时间排序。

不用Counter()也可以这样写：

def areItersEqual(a1, a2):
    c = {}
    for word in a1:
        if word in c:
            c[word] += 1
        else:
            c[word] = 0

    for word in a2:
        if word in c:
            c[word] -= 1
        else:
            return False
return not(bool([v for k,v in c.items() if v!=0]))

【讨论】：

【解决方案2】：

您可以获取每个字符串的哈希值并进行比较，而不是对字符串进行排序。（这些你可能想要排序。）

但是，如果哈希值相等，这仍然需要您直接比较字符串，因为哈希冲突可能会产生误报。

【讨论】：

【解决方案3】：

只需使用 Javascript 检查以下代码 :)

var a1 = ["abc", "abc", "bcd", "efg"];
var a2 = ["bcd", "efg", "abc", "abc"]
var allIndexExist = true;
for (var i = 0; i < a1.length; i++) {
    var index = a2.indexOf(a1[i]);
    if (index == -1) {
        allIndexExist = false;
        break;
    } else {
        a2.splice(index, 1);
    }
}
if (a2.length > 0 || !allIndexExist) {
    console.log("Array is not equal");
} else {
    console.log("Array is equal");
}

【讨论】：

indexOf 仍然必须枚举整个数组并执行多个字符串比较。这应该仍然是 O(n^2)。但这也是个好主意，谢谢。

【解决方案4】：

斯威夫特：

  func test() -> Bool {
    var a1 = ["abc", "abc", "bcd", "efg"]
    var a2 = ["bcd", "efg", "abc", "abc"]
    if a1.count != a2.count {
       return false
    }
    var temp = [String: Int]()

    for ele in a1 {
        if let count = temp[ele] {  //  if temp contain key
            temp[ele] = count + 1
        } else {
            temp[ele] = 1
        }
    }

    for ele in a2 {
        if let count = temp[ele] { //  if temp contain key 
           if count == 0 {
              return false
           } else if count == 1 {
              temp[ele] = nil
           } else {
              temp[ele] = count - 1
           }           
        } else {
           return false
        }
    }
    return temp.count == 0
}

print(test())

这个函数只能通过枚举两个数组来解决。 O(n)

【讨论】：