Arrays 判断两个数组是否相等-在没有任何数据假设的情况下O（n）是可能的吗？

我一直在想，判断两个无序的数组是否由相同的元素组成的最坏情况下的时间复杂性。元素可以是任何类型。数字、字符串、自定义对象。。。等等，但让我们假设元素既可排序又可散列

我想到了三种方法，在中有很好的解释。它们是1）使用散列2）使用排序3）只是循环通过

邮报说，如果数据是可散列的，就有可能实现最坏时间

O（n）

，但是，我认为这并不完全正确，因为在散列中插入和搜索并不是最坏情况下的

O（1）

操作。如果没有发生碰撞，则平均为

O（1）

，但在插入和搜索（理论上）都是

O（n）

。因此，如果发生大量冲突，使用哈希告诉两个数组相等将花费

O（n^2）

。（如果我错了，请纠正我。）

因此，在我看来，告诉两个数组相等的代价与对数组进行排序一样高，而在不了解数组的情况下，排序的代价是

O（nlogn）

。（假设比较两个相等的元素总是要花费

O（1）

）

在最坏的情况O（n）下，是否可以判断两个数组相等？我将感谢任何评论，重复的旗帜，参考文件。谢谢

下面是我用来比较两个数组是否相等的代码。（它在ruby中运行，但请看它更像一个伪代码）

一个。通过散列进行比较-平均而言，

O（n）

，最坏情况，

O（n^2）

两个。通过排序进行比较。最坏情况

O（nlogn）

三个。通过循环进行比较。最坏情况

O（n^2）

编辑 我欣赏并理解散列操作通常会显示O（1）时间复杂性的答案和评论，最坏情况的情况不太可能发生。然而，由于它们无论如何都可能发生，我不想忽视这些可能性。我很抱歉没有把我的观点讲清楚。我的第一个意图是找到理论上证明过的O（n）算法，而不是实用的算法。

---

谢谢你的关注。非常感谢。

使用哈希时最糟糕的时间复杂度是O（n）（假设您正确创建了哈希实现）。这里最糟糕的情况是输入（不考虑hashtable的糟糕实现）

您在上面所做的是当您的哈希表实现不好并且有n个冲突时

---

考虑到您有一个好的哈希函数，它在哈希表中唯一地分配密钥，并且没有冲突，最坏情况下的时间复杂度将是O（n）。因为您可以在一次传递中进行比较。这种方式比排序和比较（需要O（nlogn）时间）更有效

使用哈希时，最坏情况下的时间复杂度为O（n）（假设您正确创建了哈希实现）。这里最糟糕的情况是输入（不考虑hashtable的糟糕实现）

您在上面所做的是当您的哈希表实现不好并且有n个冲突时

---

考虑到您有一个好的哈希函数，它在哈希表中唯一地分配密钥，并且没有冲突，最坏情况下的时间复杂度将是O（n）。因为您可以在一次传递中进行比较。这种方式比排序和比较（需要O（nlogn）时间）更有效

否，如果无法对数据进行任何假设，则无法确定比较最坏情况下运行时间为O（n）的2个数组

您对哈希表最坏情况的分析是正确的

为什么不呢？

您可以预处理数组，也可以不预处理：

如果你做预处理，你能得到的最好的情况是O（n*log（n））（通过排序）

如果不进行预处理，则需要将1个数组中的每个元素与第二个->O（n^2）中的每个元素进行比较

---

---

p、 s:不幸的是，我还没有找到正式的证据。

不，如果不能对数据进行任何假设，就不可能确定地比较最坏情况下运行时间为O（n）的两个数组

您对哈希表最坏情况的分析是正确的

为什么不呢？

您可以预处理数组，也可以不预处理：

如果你做预处理，你能得到的最好的情况是O（n*log（n））（通过排序）

如果不进行预处理，则需要将1个数组中的每个元素与第二个->O（n^2）中的每个元素进行比较

---

---

p、 s:不幸的是，我还没有找到正式的证明。

是的，你可以用散列法

如果散列函数对数据集非常不利，则在散列中会发生冲突，如果散列函数为常量（总是返回1或类似的值），则可能只会得到O（N^2）

---

实际上，您可以使用加密哈希函数，并且可以相当确定不会发生太多哈希冲突。这是因为没有人可以故意生成具有相同say SHA-1散列的输入（许多人正在尝试）。或者尝试一个完美的散列算法

---

所以你的最坏情况分析是基于错误的假设。使用好的散列函数可以保证始终接近平均情况，而不会出现最坏情况。

是的，可以使用散列

如果散列函数对数据集非常不利，则在散列中会发生冲突，如果散列函数为常量（总是返回1或类似的值），则可能只会得到O（N^2）

---

实际上，您可以使用加密哈希函数，并且可以相当确定不会发生太多哈希冲突。这是因为没有人可以故意生成具有相同say SHA-1散列的输入（许多人正在尝试）。或者尝试一个完美的散列算法

所以你的最坏情况分析是b

def compare_by_hashing(list1, list2)  
  hash1 = {}  
  list1.each do |item|  
    hash1[item] ||= 0  
    hash1[item] += 1  
  end  
  hash2 = {}  
  list2.each do |item|  
    hash2[item] ||= 0  
    hash2[item] += 1  
  end  

  hash1.each do |key, hash_1_value|  
    return false if hash_1_value != hash2[key]  
  end  
  return true  
end  

# 2. compare by sorting. Worst-case `O(nlogn)`
def compare_by_sorting(list1, list2)  
  list1.sort  
  list2.sort  

  list1.each_with_index do |list_1_item, index|  
    return false if list_1_item != list2[index]  
  end  
  return true  
end  

def compare_by_looping(list1, list2)  
  list1.each do |item|  
    if list2.include? item  
      list2.delete item  
    else  
      return false  
    end  
  end  
  return true  
end