常用排序演算法及其實現

1. 插入排序：遍歷陣列(n)，將每個元素插入到前面子串行的合適位置（插入時採取前面的部分元素後移，再將本元素填在適當位置的方法）

模擬：12 30 9 100 1 3 10

12 30 9 100 1 3 10

9 12 30 100 1 3 10

1 9 12 30 100 3 10

1 3 9 12 30 100 10

1 3 9 10 12 30 100

實現**：

1/*2
插入排序: 
3平均：o(n2)
4最好：o(n)
5最壞：o(n2)
6穩定性：穩定7*/
8void insertsort(vector &nums)925
}26}27 }

2. 氣泡排序：雙層迴圈，外層從後往前，裡層從前往後，如果後面比前面小，就交換。

模擬：1 3 2 7 5 6 9 8 4

1 2 3 5 6 7 8 4 9

1 2 3 5 6 7 4 8 9

1 2 3 5 6 4 7 8 9

1 2 3 5 4 6 7 8 9

1 2 3 4 5 6 7 8 9

實現**：

1/*2
氣泡排序: 通過兩兩交換的方式，每次將子區間最大的冒向最後
3平均：o(n2)
4最好：o(n)
5最壞：o(n2)
6穩定性：穩定7*/
8//普通氣泡排序
9void bubblesort(vector &nums)
1024}25
}26}27
28//
冒泡優化版本：新增標誌位或者計數器判斷序列是否已經有序
29void bubblesort2(vector &nums)
3045
else
46 flag ++;47}
48if(flag ==i)
49return;50
}51 }

3. （簡單）選擇排序：本位和後面子序列中最小的交換

模擬：1 3 2 7 5 6 9 8 4

1 32 7 5 6 9 8 4

1 2 3 7 5 6 9 8 4

1 2 3 4 5 6 9 8 7

1 2 3 4 5 69 8 7

1 2 3 4 5 6 7 8 9

實現**：

1/*2
選擇排序: 每個子區間找到最小與第乙個交換
3平均：o(n2)
4最好：o(n)
5最壞：o(n2)
6穩定性：穩定7*/
8void choosesort(vector &nums)921
if (nums[i] >nums[min])
22swap(nums[i], nums[min]);23}
24 }

4. 快排：思想是，一趟挑出1個數，將陣列分成左右兩部分，左邊小於該數，右邊大於該數。維護有兩個索引（low, high)，隨機將陣列中乙個數定為「基準」，先從high右往左找到第乙個比基準小的與基準交換，更新low和high，再從low左往右找第乙個大於基準的與基準交換，更新low和high。直到low == high。進行下一趟，一般三趟足以。（第一堂完成後左邊再選乙個，右邊再選乙個即可。）

模擬：1 3 2 7 5 6 9 8 4

4 3 2 7 5 6 9 8 1

4 3 2 1 5 6 9 8 7

（一趟結束）

實現**：

1/*2
快速排序: 
3平均：o(nlogn)
4最好：o(nlogn)
5最壞：o(n2) 完全有序時出現
6穩定性：不穩定7*/
8//分治法：遞迴實現
9void quicksort(vector &nums, int l, int
r)10
24//
從右往左找到第乙個小於key的數
25while(nums[--j] >key)
2630
//判斷位置，交換兩數
31if(i >=j)
32break;33
int tmp =nums[i];
34 nums[i] =nums[j];
35 nums[j] =tmp;36}
37//
分割完成後，遞迴兩部分
38int tmp =nums[l];
39 nums[l] =nums[j];
40 nums[j] =tmp;
41 quicksort(nums, l, j-1
);42 quicksort(nums, j+1
, r);
43 }

5. 堆排序：對所給陣列進行建大頂堆，將堆頂元素與最後乙個交換，尾索引前移，繼續建立大頂堆，如此類推。

1/*2
堆排序: 在陣列基礎上構建大/小頂堆來實現排序 
3平均：o(nlogn)
4最好：o(nlogn)
5最壞：o(nlogn) 
6穩定性：不穩定7*/
8//調整範圍堆頂值，保持大頂
9void heapadjust(vector &nums, int index, int
length)
1025
return;26
}2728//
堆排序：遞迴方式實現
29void heapsort(vector &nums)
3039
//堆排序
40for (int i = len - 1; i >= 0; i--)
4149 }

6.歸併排序：將原始陣列分成若干個子串行，兩兩合併排序，再合併排序......直到合併完成。

（同數量級排序方法中效能最好的---又快又穩定）

模擬：1 3 2 7 5 6 9 8 4

[1 3] [2 7] [5 6] [8 9] [4]

[1 2 3 7] [5 6 8 9] [4]

[1 2 3 5 6 8 9] [4]

[1 2 3 4 5 6 7 8 9]

實現**：

1/*2
二路歸併排序: 
3平均：o(nlogn)
4最好：o(nlogn)
5最壞：o(nlogn) 完全有序時出現
6穩定性：穩定，但很少用7*/
8//合併二路陣列
9void merge(vector &nums, vector &res, int l, int m, int
r)10
22//
剩下的部分
23if(i <=m)
2428
else
2933
//將二路合併結果複製回去
34for(int i=l; i<=r; i++)
35 nums[i] =res[i];36}
3738
//二路分割
39void mergesort(vector &nums, vector &res, int l, int
r)40
48 }

7. 希爾排序：要選步長，每隔乙個步長選定乙個元素，對選定的序列排序，再選一次再排；完成後換步長再排。步長的選取很重要，但沒有好的選取方法。

一位大佬的總結：

常用排序演算法及其實現

常用排序演算法及其實現

kmeans演算法及其實現

單鏈表的快速排序演算法及其實現

常用排序演算法及其實現

常用排序演算法及其實現

kmeans演算法及其實現

單鏈表的快速排序演算法及其實現

相關推薦