Question

我正在编写一个算法，以确定在排序数组中是否存在一对整数给定整数。我希望算法在O（n）中运行，其中n是子数组中的整数数。

输入是子数组和整数的边界，用于测试总和。输出将是一个布尔值。

这是我的算法。 k是给定的整数，i和j是子数组的边界。

kPairSumInterval(int k, int i, int j)
         if(i == (j-1))
              sum = A[i] + A[j]
              if(sum == k)
                 found = true;

         kPairSumInterval(k,i+1,j)
         for j down to i
              sum = A[i] + A[j]
              if(sum == k)
                  found = true

        return found

while循环是否会影响运行时间，还是只关注递归所做的堆栈帧数？如果算法不会在O（n）时间内运行，我会很感激一些建议让它在O（n）中运行。

Answer 1

对排序列表的简单算法。
假设所有正整数，请在列表末尾设置索引，在列表开头设置索引，并根据减量结束索引或增加起始索引。
Python伪代码：

def kPairSumInterval(k, i, j):
    x, y = i, j-1
    while x < y and A[x] + A[y] != k:
        if A[x] + A[y] > k:
            y -= 1
        else:
            x += 1
    return x < y

仅出于演示目的，使用布尔算法递归地使用相同的算法，即True==1和False==0：

def kPairSumInterval(k, i, j):
    if i >= j-1:
        return False
    result = A[i] + A[j-1]
    if result == k:
        return True
    return kPairSumInterval(k, i+(result < k), j-(result > k))

Answer 2

你可以使用2个指针

从索引0开始一个，从索引n-1
检查总和是否小于预期总和增加前指针并检查。
如果它更小，减少后退指针并检查。
终止条件将指针相互交叉。

ALGO

desired_vale;
sum=0;
int p1,p2;
sortedArray[n];
p1=0;
p2=n-1;
for(;p1<p2;) // since you need pair = not required
{
sum = sortedArray[p1] + sortedArray[p2];
if(sum==desired_vale)
  return true ; //pair exist
else if (sum < desired_vale)
   p1++;
else
   p2-- ; 
}
return false; // could not find pair

这里的catch是排序数组，因此可以通过给定的方法按log（n）的顺序完成。

Answer 3

众所周知的双指针算法（Delphi）的递归版本。线性复杂性。

function FindSum(const A: array of Integer; Sum, l, r: Integer): Boolean;
var
  s: Integer;
begin
  if l >= r then
    Result := False
  else  begin
    s := A[l] + A[r];
    if s = Sum then
      Result := True
    else if s > Sum then
      Result := FindSum(A, Sum, l, r - 1)
    else
      Result := FindSum(A, Sum, l + 1, r)
  end;
end;

这个算法可以在O（n）时间内运行吗？

3 个答案: