氣泡排序：

思想：兩兩交換，大的放到後面。重複size-1次

程式碼實現：

1. //氣泡排序
2. void Bubble_Sort(int array[],int size)  
3. {  
4.     for(int idx= 0; idx < size;++idx)  
5.     {  
6.        for(int index= 0; index < size-1-idx;++index)  
7.        {  
8.            if(array[index]> array[index+1])  
9.            {  
10.               std::swap(array[index],array[index+1]);  
11.            }  
12.        }  
13.     }  
14. }  

氣泡排序的優化：

思想：對氣泡排序常見的改進方法是加入一標誌性變數flag，用於標誌某一趟排序過程中是否有資料交換，如果進行某一趟排序時並沒有進行資料交換，則說明資料已經按要求排列好，可立即結束排序，避免不必要的比較過程。

程式碼實現：

1. //氣泡排序優化
2. void Bubble_Sort2(int array[], int size)  
3. {  
4.     bool flag = true;  
5.     while (flag)  
6.     {  
7.         flag = false;  
8.         for
    (int index = 0; index < size - 1; ++index)  
9.         {  
10.             if (array[index] > array[index + 1])  
11.             {  
12.                 std::swap(array[index], array[index + 1]);  
13.                 flag = true;  
14.             }  
15.         }  
16.     }  
17. }  

快速排序：

遞迴：

快速排序第一種方法：

思想：選取一個數字為比較值，用右值和他比較，如果右值比他小就將他給左邊，左邊加一。

若左邊比他大，就將他給右邊，右邊減一。如此當left==right時，說明此比較值的地方就應該在此，然後遞迴，先排此地點的左邊再排此地點的右邊。

優化：可以寫一個函式為查詢最左邊下標，最右邊下標以及中間下標的中間值，在陣列範圍內比較陣列下標第一個，最後一個，和中間值得元素，儘可能將值為中間的元素當成key值，這樣可以提高效率。（因為遞迴時左和右都有將近一半的資料）

程式碼：

1. //三數取中法
2. int FindMidIndex(int array[],int left,int right)  
3. {  
4.     int mid= right - ((right- left) >> 1);  
5.     if(array[left]<= array[mid])  
6.     {  
7.        if(array[right]< array[left])  
8.            return left;  
9.        if(array[right]> array[mid])  
10.            return mid;  
11.        else
12.            return right;  
13.     }  
14.     if(array[left]> array[mid])  
15.     {  
16.        if(array[right]> array[mid])  
17.            return mid;  
18.        if(array[right]> array[left])  
19.            return left;  
20.        else
21.            return right;  
22.     }  
23.     return 0;  
24. }  

全過程

時間複雜度：O（NlogN）

空間複雜度：O（1）

穩定性：不穩定

程式碼實現：

1. int Quick_Pass1(int array[],int left,int right)  
2. {  
3.     //設定一個比較的值儘量讓比較值為較為中間的值
4.     int keyIdx= FindMidIndex(array,left,right);  
5.     std::swap(array[keyIdx],array[right]);  
6.     int temp= array[right];  
7.     while(left < right)  
8.     {  
9.        //如果這時左邊比比較值大左邊給右邊右邊前移
10.        while(left < right&& array[left]< temp)  
11.            left++;  
12.        if(left < right)  
13.        {  
14.            array[right]= array[left];  
15.            right--;  
16.        }  
17.        //如果右邊比比較值小則右邊的數值給左邊，左邊後移
18.        while(left < right&& array[right]>= temp)  
19.            right--;  
20.        if(left < right)  
21.        {  
22.            array[left]= array[right];  
23.            left++;  
24.        }  
25.     }  
26.     //最後一個他倆相等的時候把中間比較值給過來返回中間的下標
27.     array[left]= temp;  
28.     returnleft;  
29. }  

快速排序第二種方法：

思路：給兩個指標，第一個為Cur，第二個為prev，比較值為key，當Cur小於等於right時就一直迴圈。（這裡如果沒有等於就會少比較一次）當cur下標的元素小於比較值得時候，並且++prev！=cur ,就讓array[cur]和array[prev]交換。當走完了之後，最後一個數據array[right]應該和array[++prev]交換，因為沒有比較最後一個（cur下標的元素小於比較值，這裡沒有等於），也就少換了一個。

一趟之後：

程式碼實現：

1. //設定一個Pre與Cur 當Cur<=right的時候，就迴圈
2. //當遇到Cur<key且Pre下一個不為Cur時,就讓array[Cur]與array[Pre]交換
3. //找小於key的數與大於key的數字交換
4. int Quick_Pass2(intarray[],intleft,intright)  
5. {  
6.     int cur= left;  
7.     int prev= cur - 1;  
8.     int keyIdx= FindMidIndex(array,left,right);  
9.     std::swap(array[keyIdx],array[right]);  
10.     int key= array[right];  
11.     while(cur <= right)  
12.     {  
13.        //這裡不用<=是因為防止重複資料若出現重複複數據會交換很多次
14.        if(array[cur]< key && ++prev!= cur)  
15.            std::swap(array[cur],array[prev]);  
16.        ++cur;  
17.     }  
18.     std::swap(array[++prev],array[right]);  
19.     return prev;  
20. }  

遞迴優化：

我們可知，當資料量較小的時候直接插入排序比較高效，所以當資料量較小的時候我們可以選擇插入排序，當資料量較大的時候我們選擇快速排序。

程式碼實現：

1. //遞迴快速排序
2. void Quick_Sort(intarray[],intleft,intright)  
3. {  
4.     if(right - left<16)  
5.     {  
6.        Insert_Sort(array,right-left+1);  
7.     }  
8.     else
9.     {  
10.        //先找到第一個數字應該放的點
11.        intpos= Quick_Pass1(array,left,right);  
12.        //排這個數的左邊的範圍
13.        Quick_Sort(array,left,pos-1);  
14.        //排這個數右邊的範圍
15.        Quick_Sort(array, pos+ 1,right);  
16.     }  
17. }  

快速排序非遞迴：

思路：遞迴轉換為非遞迴一般用棧。我們向棧中儲存陣列下標，通過迴圈來進行排序。

程式碼實現：

1. //非遞迴快速排序
2. void Quick_Sort_Nor(intarray[],intleft,intright)  
3. {  
4.     stack<int> s;  
5.     s.push(right);  
6.     s.push(left);  
7.     while(!s.empty())  
8.     {  
9.        left= s.top();  
10.        s.pop();  
11.        right= s.top();  
12.        s.pop();  
13.        intdiv= Quick_Pass2(array,left,right);  
14.        //此時可能會出現越界的問題如果最後一個就為最大值或者第一個就為最小值
15.        if(div - 1 > left)  
16.        {  
17.            //因為上面是先讀取左再讀取右  所以這裡為先壓右再壓左
18.            s.push(div - 1);  
19.            s.push(left);  
20.        }  
21.        if(div + 1 < right)  
22.        {  
23.            s.push(right);  
24.            s.push(div + 1);  
25.        }  
26.     }  
27. }  

鴿巢排序：

思路：如果遇見資料量大，資料雜亂度較高的一組資料。我們可以通過重新建立一個數組，此陣列中儲存數字出現的次數，下標加上最小的一個數字，此數字就為存入的數字。

最終只需要在新陣列中存放儲存數字即可。

時間複雜度：O（M+N）（M為存元素數目的區間，N為原陣列區間）

相關推薦