此算法可以在O（n）時間內運行嗎？

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開始第二個
• 如果總和小於所需總和，請增加前指針並進行檢查。
• 如果小於，請減小后退指針並檢查。
• 終止條件是指針彼此交叉。

阿爾戈

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

這里的捕獲是排序后的數組，因此可以通過給定方法按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;