Question

什么是（a）最坏情况，（b）最佳情况，以及（c）以下函数的平均大小写复杂度，它进行冒泡排序

for i=1 to n-1 do
    for j=i to n-1 do
        if x[j]>x[j+1] then
            temp=x[j]
            x[j]=x[j+1]
            x[j+1]=temp
        end {if}
    end {for}
end {for}

你如何证明这种复杂性？

Answer 1

最坏的情况是O（n ²）。

平均情况也是O（n ²）。

最糟糕的情况是O（n ²），即使if语句中的代码在这种情况下也不会被执行。二次复杂性是由于两个for循环将在所有三种情况下完全执行，而与列表的内容无关。

Answer 2

这也适用于下面的BubbleSort算法，因为while也是O（n）。

public static void BubbleSort( int [ ] num )
    {
        int j;
        boolean flag = true;  
        int temp;  

        while ( flag )
        {

            flag= false;   
            for( j=0;  j < num.length -1;  j++ )
            {
                if ( num[ j ] > num[j+1] )   
                {
                    temp = num[ j ];                //swap elements
                    num[ j ] = num[ j+1 ];
                    num[ j+1 ] = temp;
                    flag = true;              //shows a swap occurred
                }
            }

        }

    }

Answer 3

如果您想要一个冒泡排序算法，该算法会针对最佳，最差和平均案例效率发生显着变化，请尝试以下方法：

int count = n - 1;    // The input size
bool sFlag = true;    // A flag variable allowing the inner outerloop to 
                         break early and fall through

while (sFlag ){

    sFlag = false;    // Set false so that the loop can break if no swaps occur
    for (int j = 0; j < count; j++){
        if (A[j+1] < A[j]){

            int temp;    // Swap the two elements
            temp = A[j];
            A[j] = A[j+1];
            A[j+1] = temp;

            sFlag = true;    // A swap has occured, iterate again
        }
    }
    count--;    //Next time, don't bother looking at the last element, it is 
                  in order

}

最坏的情况是Cworst（n）= 1 / 2n（n + 1），最好的情况是Cbest（n）= n-1。这是因为count变量使内循环迭代次数减少，这取决于相对于输入大小已经完成的迭代量。

这是我迄今为止遇到的最有效的冒泡方式。

冒泡排序最坏情况，最佳案例和平均案例复杂性

3 个答案: