Algorithm 数组中两个整数的和等于K

我阅读，因为它们是相关的

我知道一个O（n）解，但我看到O（n logn）也存在：-

p=0,q=n-1;
while(p<q)
{
  if(a[p]+a[q]==k)
  {
      cout<<a[p]<<"\t"<<a[q];
      p++;
      q--;
   }
   else if(a[p]+a[q]>k)
      q--;
   else 
      p++;
}

p=0，q=n-1；
虽然（p如果你有一个
O（n）
解决方案，你不需要关心
O（n log n）
一个，因为那更糟糕，除非
O（n）
解决方案还有一些其他问题，比如像
O（n^（n^（n^）n））
：-）

在任何情况下，您所展示的算法也是
O（n）
，因为您在每次迭代中要么增加低索引，要么减少高索引

我怀疑您提到的
O（n log n）
首先包括未排序数据的初始排序，因为这是排序的典型时间复杂性。
高效排序算法的复杂性是
O（n log n）

无论
p
和
q
以何种方式变化，
while
循环都会遍历数组中的所有元素一次，因此其复杂性为
O（n）

将两者相加：
O（n logn）+O（n）=O（n logn+n）=O（n logn）
，因为当
n
是一个大数字时，n远小于
n logn
 python中的

arr = [1, 2, 4, 6, 10]
diff_hash = {}
expected_sum = 3
for i in arr:
    if diff_hash.has_key(i):
        print i, diff_hash[i]
    key = expected_sum - i
    diff_hash[key] = i

算法：

输入：预期的\u和
diff_hash=哈希表数据结构
对于（i=0），iO（n logn）时间包括排序。根据我的说法，该算法具有O（n）复杂性，因为在每次迭代中，您至少增加或减少一个计数器。
Input: expected_sum

diff_hash = hashtable_datastructure
for(i=0, i<len(arr), i++)
{ 
   if(diff_hash(arr[i])) 
   { 
      return arr[i] , diff_hash(arr[i])
   } 
   key = expected_sum - arr[i] 
   diff_hash(key) = arr[i] 
 }