僅查看算法代碼即可計算時間復雜度

Question

我目前已經學習了所有使用的排序算法的代碼，並了解了它們的功能。 然而，作為這些的一部分，人們也應該能夠發現時間和空間的復雜性。 我看到人們只是看着循環並推導其復雜性。 有人可以指導我實現最佳實踐。 給定的示例代碼用於“ Shell排序”。 從代碼本身理解和計算的策略應該是什么。 請幫忙！ 有點像步數法。 需要了解如何從代碼本身進行漸進分析。 請幫忙。

int i,n=a.length,diff=n/2,interchange,temp;
while(diff>0) { 
    interchange=0;
    for(i=0;i<n-diff;i++) {
        if(a[i]>a[i+diff]) { 
            temp=a[i];
            a[i]=a[i+diff];
            a[i+diff]=temp;
            interchange=1;
        }
    }
    if(interchange==0) {
        diff=diff/2;
    }
} 

Answer 1

由於最壞情況下的比較排序算法的絕對下限是O（n log n） ，因此顯然不能做得更好。 同樣的復雜性在這里。

最壞情況下的時間復雜度 ：

1.內循環

讓我們首先開始分析內部循環：

for(i=0;i<n-diff;i++) {
    if(a[i]>a[i+diff]) {
        temp=a[i];
        a[i]=a[i+diff];
        a[i+diff]=temp;
        interchange=1;
    }
}

由於我們在此級別上對a的結構了解不多（一無所知），因此肯定有條件成立，因此發生交換。 因此， 保守的分析表明，在循環結束時interchange可能為0或1 。 但是我們知道，如果第二次使用相同的diff值執行循環。

當您自己評論時，循環將執行O（n-diff）次。 由於循環內的所有指令都需要固定的時間。 循環本身的時間復雜度也是O（n-diff） 。

現在的問題是，在變為0之前，可以將1 interchange多少次。 最大界限是放置在絕對右邊的項目是最小元素，因此將保持“交換”狀態直到到達列表的開頭。 因此，內部循環本身最多重復：O（n / diff）次。 結果，循環的計算工作量是最壞的情況：

O(n^2/diff-n)=O(n^2/diff-n)

---

2.具有不同diff外循環

外循環依賴於diff的值。 從n/2值開始，在循環結束時給定interchange等於1 ，我們無法證明情況並非如此，將diff設置為diff/2會執行新的迭代。 重復該過程，直到diff < 1為止。 這意味着diff將取2所有冪直到n/2 ：

1 2 4 8 ... n/2

現在我們可以通過總結來進行分析：

log2 n
------
 \
 /      O(n^2/2^i-n) = O(n^2)
------
i = 0

其中， i表示給定迭代的* log ₂ （diff）。 如果我們解決這個問題，我們將得到O（n ² ）最壞情況的時間復雜度。

注意 （在最壞情況比較排序的下限上）：可以證明不存在最壞情況時間復雜度為O（n log n）的比較排序算法。

這是因為對於具有n個項目的列表，有n個！ 可能的訂單。 對於每種訂購，都有一種不同的方式來重組列表。

由於使用比較可以將一組可能的排序最好地分為兩個相等的部分，因此至少需要進行log ₂ （n！）個比較才能找出我們正在談論的排序。 log ₂ （n）的復雜度可以使用斯特林近似來計算：

  n /\\ | | log(x) dx = n log n - n = O(n log n) \\/ 1 

最佳情況下的時間復雜度：在最佳情況下，列表顯然是有序的。 在這種情況下，內部循環將永遠不會執行if-then部分。 結果， interchange將不會設置為1 ，因此在執行了一次for循環之后。 外循環仍將重復O（log n）次，因此時間復雜度為O（n log n） 。

Answer 2

查看循環並嘗試找出它們執行了多少次。 從最內在的開始。

在給定的示例中（不是最簡單的示例），在范圍[0,n-diff]對for循環（最內部）進行i運算，即，它正好執行n-diff次。

只要需要“恆定時間”，在該循環內完成的操作實際上並不重要，即，原子操作數量有限。

現在，只要diff>0就執行外循環。 此行為很復雜，因為迭代可以降低diff或不降低（未找到反向對時降低）。

現在您可以說diff將減少log(n)次（因為減半直到0），並且在每次減少之間，內部循環都會“運行一定次數”。

訓練有素的眼睛還將識別交錯的冒泡通過，並得出結論，該次數不會超過所涉及元素的數量，即n-diff ，但這幾乎可以“一目了然”。

對該算法的完整分析令人頭疼，因為數組越來越好，排序越來越好，這將影響內部循環的數量。