冒泡算法的簡要分析

博主是邊學習邊寫的，看了很多的冒泡算法講解，覺得不夠詳細，研究了很久才弄懂，看似簡單還是要實現以下才行，記錄學習過程。

1.  冒泡排序講解

實現方法：

1）比較相鄰的元素，如果第一個比第二個大，那麼交換兩個元素

2）對每一對相鄰元素做同樣的工作， 從第一對到最後一對，這時候最大的數字在最後的位置

3）針對所有元素重複以上步驟，除了最後一個

4）持續每次對越來越少的元素重複上面的步驟，直到沒有一對元素需要比較。

文字描述沒懂的話，來看看例子~~~

首先原始隊列爲： 5 9 7 6 1 8 13 4

一共八個數，一般比較7趟就可以按從小到大的順序排列好

外部循環控制循環趟數(i)，內部循環控制比較次數(j)

第0趟： （此時定位i=0;i<=n-1;i++

                   j=1;j<=n-1-i;j++)

1）5 9 7 6 1 8 13 4

                2)  5 7 9 6  1 8 13 4

                3)  5 7 6 9  1 8 13 4

                4)  5 7 6 1 9  8 13 4

                5)  5 7 6 1  8 9 13 4

                6) 5 7 6 1 8  9 13 4

                7)5 7 6 1 8  9 4  13（紅色代表已經排好序的）

第1趟:    1) 5 7 6 1 8 9 4 13

               2) 5 6 7 1 8 9 4 13

              3) 5 6 1 7 8 9 4 13

             4) 5 6 1 7 8 9 4 13

             5) 5 6 1 7  8 9 4 13

             6) 5 6 1 7 8  4 9  13

第2趟：1）5 6 1 7 8 4 9 13

              2） 5 1 6 7 8 4 9 13

              3）5 1  6 7 8 3 9 13

              4）5 1 6 7 8 3 9 13

             5） 5 1 6 7 3 8 9 13

           6） 5 1 6 7 3  8 9 13

第3趟：1）1 5 6 7 3 8 9 13

              2） 15 6 7 3 8 9 13

             3）1 5 6 7 3 8 9 13

             4）1 5 6 3 7 8 9 13

第4趟:1) 1 5 6 3 7 8 9 13

            2)1 5 6 3 7 8 9 13

           3) 1 5  3 6 7 8 9 13

  第5趟：1） 1 5  3 6 7 8 9 13

                2）1 3_5  6 7 8 9 13

第6趟： 1）1 3 5 6 7 8 9 13   

代碼實現：

void BubbleSort1(int arr[],int len)
{
    int i = 0;
    int j = 0;

    for(i = 0; i < len - 1; i++)
    {
        for(j = 0; j < len - i - 1; j++)
        {
            int tmp  = 0;
            if(arr[j] > arr[j+1])
            {
                tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }
        }
    }
}//沒有優化的方法，比較常規；

#include<stdio.h>
#include<stdlib.h>

int main()
{
    int arr[] = {6,5,4,3,2,1};
    int i = 0;
    int len  = sizeof(arr)/sizeof(arr[0]);

    BubbleSort3(arr,len);

    for(i = 0;i < len; i++)
        printf("%d ",arr[i]);

    system("pause");
    return 0;
}

優化算法：

1.如果原數組本身就是有一些元素是有序的，那麼就不用跑n-1趟來浪費時間，於是我們想到，可以每跑完一趟後判斷數組是否有序，一旦有序，則直接return掉；於是可以立一個flag

代碼實現：

void BubbleSort2(int arr[],int len)
{
    int i = 0;
    int j = 0;

    for(i = 0; i < len - 1; i++)
    {
        int flag = 1;//假定每次進入都是有序的 flag爲1；
        for(j = 0; j < len - i - 1; j++)
        {
            int tmp  = 0;
            if(arr[j] > arr[j+1])
            {
                tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
                flag = 0;//如果發生交換，則flag 置爲0；
            }
        }
        if(flag == 1)//如果這趟走完，沒有發生交換，則原數組有序；
            break;
    }
}//加入標誌位優化；

2.在第一種優化的基礎上，如果是100個數，僅前面10個無序，後面90個都已經排好序了，而且都大於前面的10個數字，那麼在第一趟便利後，發生交換的位置小於10，且這個位置之後的數據肯定有序了，那麼記錄下這個位置，第二次只要從頭遍歷到這個位置就可以了。

代碼實現：

void BubbleSort3(int arr[],int len)
{
    int i = 0;
    int j = 0;
    int k = len - 1;//控制內部比較循環
    int n = 0;

    for(i = 0; i < len -1 ; i++)
    {
        int flag  = 1;
        n = 0;
        //假定每次進入都是有序的 flag爲1；
        for(j = 0; j < k; j++)
        {
            int tmp  = 0;
            if(arr[j] > arr[j+1])
            {
                tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
                flag = 0;//如果發生交換，則flag 置爲0；
                n = j;//保存最後一次交換的下標；
            }
        }

        if(flag == 1)//如果這趟走完，沒有發生交換，則原數組有序；
            break;
        k = n;//最後一次交換的位置給k，減少比較的次數；
    }
}//最終優化