冒泡排序法为什么最佳的时间复杂度是O(n)

　　

BUBBLESORT(A)

1 for i ← 1 to length[A]

2     do for j ← length[A] downto i + 1

3            do if A[j] < A[j - 1]

4                  then exchange A[j] ↔ A[j - 1]

 

1         使用循环不变式证明算法的正确性：

初始化：首先，先证明对于第一轮迭代开始之前，循环不变式是成立的。此时i=1，而子数组为A[1..i]。亦即，它只包含一个元素A[1]，实际上就是最初A[1]中的那个元素。这个子数组是已排序的，这样就证明了循环不变式在循环的第一轮迭代开始之前是成立的。

 

保持：接下来，我们来考虑第二个性质：证明每一轮循环都能使循环不变式保持成立。从非形式化的意义上来看，j从length[A]到i+1，如果遇到后一个元素大于前一个元素时，交换两个元素的值，这就保证了A[i+1]是A[i+1..n]中最小的元素，那么考虑到A[1..i]子数组是已经排序的，且是最小的i个元素，那么A[1..i+1]子数组一定是排序的，且是A[1..n]数组中n个元素中最小的i+1个元素。这样就证明了每一轮循环都能使循环不变式保持成立。

 

终止：最后，分析一下循环结束时的情况。对于冒泡排序，当i大于n时，外层循环结束。在循环不变式中，那么意味着A[1..n]子数组包含了原来数组的最小的n个元素，且已经排序完成。但是，子数组A[1..n]其实就是整个数组，因此，整个数组就排序好了，这意味着算法是正确的。

 

2         算法分析

BUBBLESORT(A)                                         cost  times

1 for i ← 1 to length[A]                             c1    n

2     do for j ← length[A] downto i + 1              c2    sigma(n-i)(i=1..n)

3            do if A[j] < A[j - 1]                    c3    sigma(n-i)(i=1..n)

4                  then exchange A[j] ↔ A[j - 1]     c4    sigma(ti)(i=1..n)

 

求和得：

 

T(n) = c1n + (c2+c3) sigma(n-i)(i=1..n) + c4 sigma(ti)(i=1..n)

 

最坏时间情况，就是全部逆序情况，ti = n-i，

 

T(n) = c1n + (c2+c3+c4)sigma(n-i)(i=1..n)  = c1n + c5n*n – c5sigma(i)(i=1..n) 

= c1n + c5n*n  – c5n(n+1)/2

因此，冒泡排序最坏情况的时间总代价Θ(n*n)

2.4 在Stackoverflow上问到答案了。

　　我原本的代码的时间复杂度确实应该是O(n^2)，但算法可以改进，使最佳情况时为O(n)。改进后的代码为：

public void bubbleSort(int arr[]) {
    boolean didSwap;
    for(int i = 0, len = arr.length; i < len - 1; i++) {
        didSwap = false;
        for(int j = 0; j < len - i - 1; j++) {
            if(arr[j + 1] < arr[j]) {
                swap(arr, j, j + 1);
                didSwap = true;
            }
        }
        if(didSwap == false)
            return;
    }    
}