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

  

BUBBLESORT(A)

for i ← 1 to length[A]

2     do for j ← length[Adownto 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

for i ← 1 to length[A]                             c1    n

2     do for j ← length[Adownto 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;
    }    
}	
阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页