各種排序演算法總結及C#程式碼實現
排序是計算機內經常進行的一種操作，其目的是將一組“無序”的記錄序列調整為“有序”的記錄序列。分內部排序和外部排序。若整個排序過程不需要訪問外存便能完成，則稱此類排序問題為內部排序。反之，若參加排序的記錄數量很大，整個序列的排序過程不可能在記憶體中完成，則稱此類排序問題為外部排序。內部排序的過程是一個逐步擴大記錄的有序序列長度的過程。
將雜亂無章的資料元素，通過一定的方法按關鍵字順序排列的過程叫做排序。假定在待排序的記錄序列中，存在多個具有相同的關鍵字的記錄，若經過排序，這些記錄的相對次序保持不變，即在原序列中，ri=rj，且ri在rj之前，而在排序後的序列中，ri仍在rj之前，則稱這種排序演算法是穩定的；否則稱為不穩定的。
分類
穩定排序：假設在待排序的檔案中，存在兩個或兩個以上的記錄具有相同的關鍵字，在用某種排序法排序後，若這些相同關鍵字的元素的相對次序仍然不變，則這種排序方法是穩定的。其中冒泡，插入，基數，歸併屬於穩定排序，選擇，快速，希爾，堆屬於不穩定排序。
就地排序：若排序演算法所需的輔助空間並不依賴於問題的規模n，即輔助空間為O（1）,則稱為就地排序。（百度百科）
交換排序
氣泡排序
已知一組無序資料a[1]、a[2]、……a[n]，需將其按升序排列。首先比較a[1]與a[2]的值，若a[1]大於a[2]則交換兩者的值，否則不變。再比較a[2]與a[3]的值，若a[2]大於a[3]則交換兩者的值，否則不變。再比較a[3]與a[4]，以此類推，最後比較a[n-1]與a[n]的值。這樣處理一輪後，a[n]的值一定是這組資料中最大的。再對a[1]~a[n-1]以相同方法處理一輪，則a[n-1]的值一定是a[1]~a[n-1]中最大的。再對a[1]~a[n-2]以相同方法處理一輪，以此類推。共處理n-1輪後a[1]、a[2]、……a[n]就以升序排列了。降序排列與升序排列相類似，若a[1]小於a[2]則交換兩者的值，否則不變，後面以此類推。 總的來講，每一輪排序後最大（或最小）的數將移動到資料序列的最後，理論上總共要進行n(n-1）/2次交換。
程式碼實現
1 /// <summary>
2 /// 氣泡排序
3 /// </summary>
4 /// <param name="arry">要排序的整數陣列</param>
5 public static void BubbleSort(this int[] arry)
6 {
7 for (int i = 0; i < arry.Length; i++)
8 {
9 for (int j = 0; j < arry.Length - 1 - i; j++)
10 {
11 //比較相鄰的兩個元素，如果前面的比後面的大，則交換位置
12 if (arry[j] > arry[j + 1])
13 {
14 int temp = arry[j + 1];
15 arry[j + 1] = arry[j];
16 arry[j] = temp;
17 }
18 }
19 }
20 }
簡單測試
1 class Program
2 {
3 static void Main(string[] args)
4 {
5 int[] arry = new int[] { 1, 2, 3, 4, 1, -1 };
6 arry.BubbleSort();
7 for (int i = 0; i < arry.Length; i++)
8 {
9 Console.Write("\t" + arry[i]);
10 }
11 Console.Read();
12 }
13 }
結果
這裡採用的是為整型陣列新增擴充套件方法實現的氣泡排序。
優點：穩定
缺點：慢，每次只移動相鄰的兩個元素。
時間複雜度：理想情況下（陣列本來就是有序的），此時最好的時間複雜度為o(n),最壞的時間複雜度(資料反序的)，此時的時間複雜度為o(n*n) 。氣泡排序的平均時間負責度為o(n*n).
快速排序
設要排序的陣列是A[0]……A[N-1]，首先任意選取一個資料（通常選用陣列的第一個數）作為關鍵資料，然後將所有比它小的數都放到它前面，所有比它大的數都放到它後面，這個過程稱為一趟快速排序。值得注意的是，快速排序不是一種穩定的排序演算法，也就是說，多個相同的值的相對位置也許會在演算法結束時產生變動。
一趟快速排序的演算法是：
1）設定兩個變數i、j，排序開始的時候：i=0，j=N-1；
2）以第一個陣列元素作為關鍵資料，賦值給key，即key=A[0]；
3）從j開始向前搜尋，即由後開始向前搜尋(j–)，找到第一個小於key的值A[j]，將A[j]和A[i]互換；
4）從i開始向後搜尋，即由前開始向後搜尋(i++)，找到第一個大於key的A[i]，將A[i]和A[j]互換；
5）重複第3、4步，直到i=j； (3,4步中，沒找到符合條件的值，即3中A[j]不小於key,4中A[i]不大於key的時候改變j、i的值，使得j=j-1，i=i+1，直至找到為止。找到符合條件的值，進行交換的時候i， j指標位置不變。另外，i==j這一過程一定正好是i+或j-完成的時候，此時令迴圈結束）。
程式碼實現
1 /// <summary>
2 /// 快速排序
3 /// </summary>
4 /// <param name="arry">要排序的陣列</param>
5 /// <param name="left">低位</param>
6 /// <param name="right">高位</param>
7 public static void QuickSort(this int[] arry, int left, int right)
8 {
9 //左邊索引小於右邊，則還未排序完成
10 if (left < right)
11 {
12 //取中間的元素作為比較基準，小於他的往左邊移，大於他的往右邊移
13 int middle = arry[(left + right) / 2];
14 int i = left - 1;
15 int j = right + 1;
16 while (true)
17 {
18 //移動下標，左邊的往右移動，右邊的向左移動
19 while (arry[++i] < middle && i < right);
20 while (arry[--j] > middle && j > 0);
21 if (i >= j)
22 break;
23 //交換位置
24 int number = arry[i];
25 arry[i] = arry[j];
26 arry[j] = number;
27
28 }
29 QuickSort(arry, left, i - 1);
30 QuickSort(arry, j + 1, right);
31 }
32 }
簡單測試
1 static void Main(string[] args)
2 {
3 int[] arry = new int[] { 34,1,221,50,44,58,12,1,1};
4 //arry.BubbleSort();
5 arry.QuickSort(0, arry.Length-1 );
6 for (int i = 0; i < arry.Length; i++)
7 {
8 Console.Write("\t" + arry[i]);
9 }
10 Console.Read();
11 }
結果
插入排序
直接插入排序
每次從無序表中取出第一個元素，把它插入到有序表的合適位置，使有序表仍然有序。
第一趟比較前兩個數，然後把第二個數按大小插入到有序表中； 第二趟把第三個資料與前兩個數從前向後掃描，把第三個數按大小插入到有序表中；依次進行下去，進行了(n-1)趟掃描以後就完成了整個排序過程。
直接插入排序屬於穩定的排序，最壞時間複雜性為O(n^2)，空間複雜度為O(1)。
直接插入排序是由兩層巢狀迴圈組成的。外層迴圈標識並決定待比較的數值。內層迴圈為待比較數值確定其最終位置。直接插入排序是將待比較的數值與它的前一個數值進行比較，所以外層迴圈是從第二個數值開始的。當前一數值比待比較數值大的情況下繼續迴圈比較，直到找到比待比較數值小的並將待比較數值置入其後一位置，結束該次迴圈。
值得注意的是，我們必需用一個儲存空間來儲存當前待比較的數值，因為當一趟比較完成時，我們要將待比較數值置入比它小的數值的後一位 插入排序類似玩牌時整理手中紙牌的過程。插入排序的基本方法是：每步將一個待排序的記錄按其關鍵字的大小插到前面已經排序的序列中的適當位置，直到全部記錄插入完畢為止。
程式碼實現
1 /// <summary>
2 /// 直接插入排序
3 /// </summary>
4 /// <param name="arry">要排序的陣列</param>
5 public static void InsertSort(this int[] arry)
6 {
7 //直接插入排序是將待比較的數值與它的前一個數值進行比較，所以外層迴圈是從第二個數值開始的
8 for (int i = 1; i < arry.Length; i++)
9 {
10 //如果當前元素小於其前面的元素
11 if (arry[i] < arry[i - 1])
12 {
13 //用一個變數來儲存當前待比較的數值，因為當一趟比較完成時，我們要將待比較數值置入比它小的數值的後一位
14 int temp = arry[i];
15 int j = 0;
16 for (j = i - 1; j >= 0 && temp < arry[j]; j--)
17 {
18 arry[j + 1] = arry[j];
19 }
20 arry[j + 1] = temp;
21 }
22 }
23 }
測試
1 static void Main(string[] args)
2 {
3 int[] arry = new int[] { 34,1,221,50,44,58,12};
4 //arry.BubbleSort();
5 //arry.QuickSort(0, arry.Length-1 );
6 arry.InsertSort();
7 for (int i = 0; i < arry.Length; i++)
8 {
9 Console.Write("\t" + arry[i]);
10 }
11 Console.Read();
12 }
結果
希爾排序
希爾排序(Shell Sort)是插入排序的一種。也稱縮小增量排序，是直接插入排序演算法的一種更高效的改進版本。希爾排序是非穩定排序演算法。該方法因DL．Shell於1959年提出而得名。
希爾排序是基於插入排序的以下兩點性質而提出改進方法的：
插入排序在對幾乎已經排好序的資料操作時，效率高，即可以達到線性排序的效率。
但插入排序一般來說是低效的，因為插入排序每次只能將資料移動一位。
基本思想
先取一個小於n的整數d1作為第一個增量，把檔案的全部記錄分組。所有距離為d1的倍數的記錄放在同一個組中。先在各組內進行直接插入排序；然後，取第二個增量d2<d1重複上述的分組和排序，直至所取的增量 =1( < …<d2<d1)，即所有記錄放在同一組中進行直接插入排序為止。
該方法實質上是一種分組插入方法
比較相隔較遠距離（稱為增量）的數，使得數移動時能跨過多個元素，則進行一次比[2] 較就可能消除多個元素交換。D.L.shell於1959年在以他名字命名的排序演算法中實現了這一思想。演算法先將要排序的一組數按某個增量d分成若干組，每組中記錄的下標相差d.對每組中全部元素進行排序，然後再用一個較小的增量對它進行，在每組中再進行排序。當增量減到1時，整個要排序的數被分成一組，排序完成。
一般的初次取序列的一半為增量，以後每次減半，直到增量為1。
程式碼實現
1 /// <summary>
2 /// 希爾排序
3 /// </summary>
4 /// <param name="arry">待排序的陣列</param>
5 public static void ShellSort(this int[] arry)
6 {
7 int length = arry.Length;
8 for (int h = length / 2; h > 0; h = h / 2)
9 {
10 //here is insert sort
11 for (int i = h; i < length; i++)
12 {
13 int temp = arry[i];
14 if (temp < arry[i - h])
15 {
16 for (int j = 0; j < i; j += h)
17 {
18 if (temp<arry[j])
19 {
20 temp = arry[j];
21 arry[j] = arry[i];
22 arry[i] = temp;
23 }
24 }
25 }
26 }
27 }
28 }
測試
1 static void Main(string[] args)
2 {
3 int[] arry = new int[] { 34,1,221,50,44,58,12};
4 //arry.BubbleSort();
5 //arry.QuickSort(0, arry.Length-1 );
6 //arry.InsertSort();
7 arry.ShellSort();
8 for (int i = 0; i < arry.Length; i++)
9 {
10 Console.Write("\t" + arry[i]);
11 }
12 Console.Read();
13 }
結果
選擇排序
簡單選擇排序
設所排序序列的記錄個數為n。i取1,2,…,n-1,從所有n-i+1個記錄（Ri,Ri+1,…,Rn）中找出排序碼最小的記錄，與第i個記錄交換。執行n-1趟 後就完成了記錄序列的排序。
在簡單選擇排序過程中，所需移動記錄的次數比較少。最好情況下，即待排序記錄初始狀態就已經是正序排列了，則不需要移動記錄。
最壞情況下，即待排序記錄初始狀態是按逆序排列的，則需要移動記錄的次數最多為3（n-1）。簡單選擇排序過程中需要進行的比較次數與初始狀態下待排序的記錄序列的排列情況無關。當i=1時，需進行n-1次比較；當i=2時，需進行n-2次比較；依次類推，共需要進行的比較次數是(n-1)+(n-2)+…+2+1=n(n-1)/2，即進行比較操作的時間複雜度為O(n^2)，進行移動操作的時間複雜度為O(n)。
程式碼實現
1 /// <summary>
2 /// 簡單選擇排序
3 /// </summary>
4 /// <param name="arry">待排序的陣列</param>
5 public static void SimpleSelectSort(this int[] arry)
6 {
7 int tmp = 0;
8 int t = 0;//最小數標記
9 for (int i = 0; i < arry.Length; i++)
10 {
11 t = i;
12 for (int j = i + 1; j < arry.Length; j++)
13 {
14 if (arry[t] > arry[j])
15 {
16 t = j;
17 }
18 }
19 tmp = arry[i];
20 arry[i] = arry[t];
21 arry[t] = tmp;
22 }
23 }
測試
1 static void Main(string[] args)
2 {
3 int[] arry = new int[] { 34,1,221,50,44,58,12};
4 //arry.BubbleSort();
5 //arry.QuickSort(0, arry.Length-1 );
6 //arry.InsertSort();
7 //arry.ShellSort();
8 arry.SimpleSelectSort();
9 for (int i = 0; i < arry.Length; i++)
10 {
11 Console.Write("\t" + arry[i]);
12 }
13 Console.Read();
14 }
結果
堆排序
堆排序(Heapsort)是指利用堆積樹（堆）這種資料結構所設計的一種排序演算法，它是選擇排序的一種。可以利用陣列的特點快速定位指定索引的元素。堆分為大根堆和小根堆，是完全二叉樹。大根堆的要求是每個節點的值都不大於其父節點的值，即A[PARENT[i]] >= A[i]。在陣列的非降序排序中，需要使用的就是大根堆，因為根據大根堆的要求可知，最大的值一定在堆頂。
程式碼實現
1 /// <summary>
2 /// 堆排序
3 /// </summary>
4 /// <param name="arry"></param>
5 public static void HeapSort(this int[] arry, int top)
6 {
7 List<int> topNode = new List<int>();
8
9 for (int i = arry.Length / 2 - 1; i >= 0; i--)
10 {
11 HeapAdjust(arry, i, arry.Length);
12 }
13
14 for (int i = arry.Length - 1; i >= arry.Length - top; i--)
15 {
16 int temp = arry[0];
17 arry[0] = arry[i];
18 arry[i] = temp;
19 HeapAdjust(arry, 0, i);
20 }
21 }
22 /// <summary>
23 /// 構建堆
24 /// </summary>
25 /// <param name="arry"></param>
26 /// <param name="parent"></param>
27 /// <param name="length"></param>
28 private static void HeapAdjust(int[] arry, int parent, int length)
29 {
30 int temp = arry[parent];
31
32 int child = 2 * parent + 1;
33
34 while (child < length)
35 {
36 if (child + 1 < length && arry[child] < arry[child + 1]) child++;
37
38 if (temp >= arry[child])
39 break;
40
41 arry[parent] = arry[child];
42
43 parent = child;
44
45 child = 2 * parent + 1;
46 }
47
48 arry[parent] = temp;
49 }
測試
1 static void Main(string[] args)
2 {
3 int[] arry = new int[] { 34,1,221,50,44,58,12};
4 //arry.BubbleSort();
5 //arry.QuickSort(0, arry.Length-1 );
6 //arry.InsertSort();
7 //arry.ShellSort();
8 //arry.SimpleSelectSort();
9 arry.HeapSort(arry.Length);
10 for (int i = 0; i < arry.Length; i++)
11 {
12 Console.Write("\t" + arry[i]);
13 }
14 Console.Read();
15 }
結果
歸併排序
歸併排序是建立在歸併操作上的一種有效的排序演算法,該演算法是採用分治法（Divide and Conquer）的一個非常典型的應用。將已有序的子序列合併，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合併成一個有序表，稱為二路歸併。
歸併過程為：比較a[i]和a[j]的大小，若a[i]≤a[j]，則將第一個有序表中的元素a[i]複製到r[k]中，並令i和k分別加上1；否則將第二個有序表中的元素a[j]複製到r[k]中，並令j和k分別加上1，如此迴圈下去，直到其中一個有序表取完，然後再將另一個有序表中剩餘的元素複製到r中從下標k到下標t的單元。歸併排序的演算法我們通常用遞迴實現，先把待排序區間[s,t]以中點二分，接著把左邊子區間排序，再把右邊子區間排序，最後把左區間和右區間用一次歸併操作合併成有序的區間[s,t]。
歸併操作(merge)，也叫歸併演算法，指的是將兩個順序序列合併成一個順序序列的方法。
如 設有數列{6，202，100，301，38，8，1}
初始狀態：6,202,100,301,38,8，1
第一次歸併後：{6,202},{100,301},{8,38},{1}，比較次數：3；
第二次歸併後：{6,100,202,301}，{1,8,38}，比較次數：4；
第三次歸併後：{1,6,8,38,100,202,301},比較次數：4；
總的比較次數為：3+4+4=11,；
逆序數為14；
歸併操作的工作原理如下：
第一步：申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合併後的序列
第二步：設定兩個指標，最初位置分別為兩個已經排序序列的起始位置
第三步：比較兩個指標所指向的元素，選擇相對小的元素放入到合併空間，並移動指標到下一位置
重複步驟3直到某一指標超出序列尾
將另一序列剩下的所有元素直接複製到合併序列尾
程式碼實現
1 /// <summary>
2 /// 歸併排序
3 /// </summary>
4 /// <param name="arry"></param>
5 /// <param name="first"></param>
6 /// <param name="last"></param>
7 public static void MergeSort(this int[] arry, int first, int last)
8 {
9 if (first + 1 < last)
10 {
11 int mid = (first + last) / 2;
12 MergeSort(arry, first, mid);
13 MergeSort(arry, mid, last);
14 Merger(arry, first, mid, last);
15 }
16 }
17 /// <summary>
18 /// 歸併
19 /// </summary>
20 /// <param name="arry"></param>
21 /// <param name="first"></param>
22 /// <param name="mid"></param>
23 /// <param name="last"></param>
24 private static void Merger(int[] arry, int first, int mid, int last)
25 {
26 Queue<int> tempV = new Queue<int>();
27 int indexA, indexB;
28 //設定indexA，並掃描subArray1 [first,mid]
29 //設定indexB,並掃描subArray2 [mid,last]
30 indexA = first;
31 indexB = mid;
32 //在沒有比較完兩個子標的情況下，比較 v[indexA]和v[indexB]
33 //將其中小的放到臨時變數tempV中
34 while (indexA < mid && indexB < last)
35 {
36 if (arry[indexA] < arry[indexB])
37 {
38 tempV.Enqueue(arry[indexA]);
39 indexA++;
40 }
41 else
42 {
43 tempV.Enqueue(arry[indexB]);
44 indexB++;
45 }
46 }
47 //複製沒有比較完子表中的元素
48 while (indexA < mid)
49 {
50 tempV.Enqueue(arry[indexA]);
51 indexA++;
52 }
53 while (indexB < last)
54 {
55 tempV.Enqueue(arry[indexB]);
56 indexB++;
57 }
58 int index = 0;
59 while (tempV.Count > 0)
60 {
61 arry[first + index] = tempV.Dequeue();
62 index++;
63 }
64 }
測試
1 static void Main(string[] args)
2 {
3 int[] arry = new int[] { 34,1,221,50,44,58,12};
4 //arry.BubbleSort();
5 //arry.QuickSort(0, arry.Length-1 );
6 //arry.InsertSort();
7 //arry.ShellSort();
8 //arry.SimpleSelectSort();
9 //arry.HeapSort(arry.Length);
10 arry.MergeSort(0, arry.Length);
11 for (int i = 0; i < arry.Length; i++)
12 {
13 Console.Write("\t" + arry[i]);
14 }
15 Console.Read();
16 }
結果
基數排序
基數排序（radix sort）屬於“分配式排序”（distribution sort），又稱“桶子法”（bucket sort）或bin sort，顧名思義，它是透過鍵值的部份資訊，將要排序的元素分配至某些“桶”中，藉以達到排序的作用，基數排序法是屬於穩定性的排序，其時間複雜度為O (nlog(r)m)，其中r為所採取的基數，而m為堆數，在某些時候，基數排序法的效率高於其它的穩定性排序法。
程式碼實現
1 /// <summary>
2 /// 基數排序
3 /// 約定:待排數字中沒有0,如果某桶內數字為0則表示該桶未被使用,輸出時跳過即可
4 /// </summary>
5 /// <param name="arry">待排陣列</param>
6 /// <param name="array_x">桶陣列第一維長度</param>
7 /// <param name="array_y">桶陣列第二維長度</param>
8 public static void RadixSort(this int[] arry, int array_x = 10, int array_y = 100)
9 {
10 /* 最大數字不超過999999999...(array_x個9) */
11 for (int i = 0; i < array_x; i++)
12 {
13 int[,] bucket = new int[array_x, array_y];
14 foreach (var item in arry)
15 {
16 int temp = (item / (int)Math.Pow(10, i)) % 10;
17 for (int l = 0; l < array_y; l++)
18 {
19 if (bucket[temp, l] == 0)
20 {
21 bucket[temp, l] = item;
22 break;
23 }
24 }
25 }
26 for (int o = 0, x = 0; x < array_x; x++)
27 {
28 for (int y = 0; y < array_y; y++)
29 {
30 if (bucket[x, y] == 0) continue;
31 arry[o++] = bucket[x, y];
32 }
33 }
34 }
35
36 }
測試
1 static void Main(string[] args)
2 {
3 int[] arry = new int[] { 34,1,221,50,44,58,12};
4 //arry.BubbleSort();
5 //arry.QuickSort(0, arry.Length-1 );
6 //arry.InsertSort();
7 //arry.ShellSort();
8 //arry.SimpleSelectSort();
9 //arry.HeapSort(arry.Length);
10 //arry.MergeSort(0, arry.Length);
11 arry.RadixSort();
12 for (int i = 0; i < arry.Length; i++)
13 {
14 Console.Write("\t" + arry[i]);
15 }
16 Console.Read();
17 }
結果
總結
整數陣列各種排序演算法擴充套件類
1 /// <summary>
2 /// 排序輔助類
3 /// </summary>
4 public static class SortExtention
5 {
6 /// <summary>
7 /// 氣泡排序
8 /// </summary>
9 /// <param name="arry">要排序的整數陣列</param>
10 public static void BubbleSort(this int[] arry)
11 {
12 for (int i = 0; i < arry.Length; i++)
13 {
14 for (int j = 0; j < arry.Length - 1 - i; j++)
15 {
16 //比較相鄰的兩個元素，如果前面的比後面的大，則交換位置
17 if (arry[j] > arry[j + 1])
18 {
19 int temp = arry[j + 1];
20 arry[j + 1] = arry[j];
21 arry[j] = temp;
22 }
23 }
24 }
25 }
26 /// <summary>
27 /// 快速排序
28 /// </summary>
29 /// <param name="arry">要排序的陣列</param>
30 /// <param name="left">低位</param>
31 /// <param name="right">高位</param>
32 public static void QuickSort(this int[] arry, int left, int right)
33 {
34 //左邊索引小於右邊，則還未排序完成
35 if (left < right)
36 {
37 //取中間的元素作為比較基準，小於他的往左邊移，大於他的往右邊移
38 int middle = arry[(left + right) / 2];
39 int i = left - 1;
40 int j = right + 1;
41 while (true)
42 {
43 //移動下標，左邊的往右移動，右邊的向左移動
44 while (arry[++i] < middle && i < right) ;
45 while (arry[--j] > middle && j > 0) ;
46 if (i >= j)
47 break;
48 //交換位置
49 int number = arry[i];
50 arry[i] = arry[j];
51 arry[j] = number;
52
53 }
54 QuickSort(arry, left, i - 1);
55 QuickSort(arry, j + 1, right);
56 }
57 }
58 /// <summary>
59 /// 直接插入排序
60 /// </summary>
61 /// <param name="arry">要排序的陣列</param>
62 public static void InsertSort(this int[] arry)
63 {
64 //直接插入排序是將待比較的數值與它的前一個數值進行比較，所以外層迴圈是從第二個數值開始的
65 for (int i = 1; i < arry.Length; i++)
66 {
67 //如果當前元素小於其前面的元素
68 if (arry[i] < arry[i - 1])
69 {
70 //用一個變數來儲存當前待比較的數值，因為當一趟比較完成時，我們要將待比較數值置入比它小的數值的後一位
71 int temp = arry[i];
72 int j = 0;
73 for (j = i - 1; j >= 0 && temp < arry[j]; j--)
74 {
75 arry[j + 1] = arry[j];
76 }
77 arry[j + 1] = temp;
78 }
79 }
80 }
81 /// <summary>
82 /// 希爾排序
83 /// </summary>
84 /// <param name="arry">待排序的陣列</param>
85 public static void ShellSort(this int[] arry)
86 {
87 int length = arry.Length;
88 for (int h = length / 2; h > 0; h = h / 2)
89 {
90 //here is insert sort
91 for (int i = h; i < length; i++)
92 {
93 int temp = arry[i];
94 if (temp < arry[i - h])
95 {
96 for (int j = 0; j < i; j += h)
97 {
98 if (temp < arry[j])
99 {
100 temp = arry[j];
101 arry[j] = arry[i];
102 arry[i] = temp;
103 }
104 }
105 }
106 }
107 }
108 }
109 /// <summary>
110 /// 簡單選擇排序
111 /// </summary>
112 /// <param name="arry">待排序的陣列</param>
113 public static void SimpleSelectSort(this int[] arry)
114 {
115 int tmp = 0;
116 int t = 0;//最小數標記
117 for (int i = 0; i < arry.Length; i++)
118 {
119 t = i;
120 for (int j = i + 1; j < arry.Length; j++)
121 {
122 if (arry[t] > arry[j])
123 {
124 t = j;
125 }
126 }
127 tmp = arry[i];
128 arry[i] = arry[t];
129 arry[t] = tmp;
130 }
131 }
132 /// <summary>
133 /// 堆排序
134 /// </summary>
135 /// <param name="arry"></param>
136 public static void HeapSort(this int[] arry, int top)
137 {
138 List<int> topNode = new List<int>();
139
140 for (int i = arry.Length / 2 - 1; i >= 0; i--)
141 {
142 HeapAdjust(arry, i, arry.Length);
143 }
144
145 for (int i = arry.Length - 1; i >= arry.Length - top; i--)
146 {
147 int temp = arry[0];
148 arry[0] = arry[i];
149 arry[i] = temp;
150 HeapAdjust(arry, 0, i);
151 }
152 }
153 /// <summary>
154 /// 構建堆
155 /// </summary>
156 /// <param name="arry"></param>
157 /// <param name="parent"></param>
158 /// <param name="length"></param>
159 private static void HeapAdjust(int[] arry, int parent, int length)
160 {
161 int temp = arry[parent];
162
163 int child = 2 * parent + 1;
164
165 while (child < length)
166 {
167 if (child + 1 < length && arry[child] < arry[child + 1]) child++;
168
169 if (temp >= arry[child])
170 break;
171
172 arry[parent] = arry[child];
173
174 parent = child;
175
176 child = 2 * parent + 1;
177 }
178
179 arry[parent] = temp;
180 }
181 /// <summary>
182 /// 歸併排序
183 /// </summary>
184 /// <param name="arry"></param>
185 /// <param name="first"></param>
186 /// <param name="last"></param>
187 public static void MergeSort(this int[] arry, int first, int last)
188 {
189 if (first + 1 < last)
190 {
191 int mid = (first + last) / 2;
192 MergeSort(arry, first, mid);
193 MergeSort(arry, mid, last);
194 Merger(arry, first, mid, last);
195 }
196 }
197 /// <summary>
198 /// 歸併
199 /// </summary>
200 /// <param name="arry"></param>
201 /// <param name="first"></param>
202 /// <param name="mid"></param>
203 /// <param name="last"></param>
204 private static void Merger(int[] arry, int first, int mid, int last)
205 {
206 Queue<int> tempV = new Queue<int>();
207 int indexA, indexB;
208 //設定indexA，並掃描subArray1 [first,mid]
209 //設定indexB,並掃描subArray2 [mid,last]
210 indexA = first;
211 indexB = mid;
212 //在沒有比較完兩個子標的情況下，比較 v[indexA]和v[indexB]
213 //將其中小的放到臨時變數tempV中
214 while (indexA < mid && indexB < last)
215 {
216 if (arry[indexA] < arry[indexB])
217 {
218 tempV.Enqueue(arry[indexA]);
219 indexA++;
220 }
221 else
222 {
223 tempV.Enqueue(arry[indexB]);
224 indexB++;
225 }
226 }
227 //複製沒有比較完子表中的元素
228 while (indexA < mid)
229 {
230 tempV.Enqueue(arry[indexA]);
231 indexA++;
232 }
233 while (indexB < last)
234 {
235 tempV.Enqueue(arry[indexB]);
236 indexB++;
237 }
238 int index = 0;
239 while (tempV.Count > 0)
240 {
241 arry[first + index] = tempV.Dequeue();
242 index++;
243 }
244 }
245
246 /// <summary>
247 /// 基數排序
248 /// 約定:待排數字中沒有0,如果某桶內數字為0則表示該桶未被使用,輸出時跳過即可
249 /// </summary>
250 /// <param name="arry">待排陣列</param>
251 /// <param name="array_x">桶陣列第一維長度</param>
252 /// <param name="array_y">桶陣列第二維長度</param>
253 public static void RadixSort(this int[] arry, int array_x = 10, int array_y = 100)
254 {
255 /* 最大數字不超過999999999...(array_x個9) */
256 for (int i = 0; i < array_x; i++)
257 {
258 int[,] bucket = new int[array_x, array_y];
259 foreach (var item in arry)
260 {
261 int temp = (item / (int)Math.Pow(10, i)) % 10;
262 for (int l = 0; l < array_y; l++)
263 {
264 if (bucket[temp, l] == 0)
265 {
266 bucket[temp, l] = item;
267 break;
268 }
269 }
270 }
271 for (int o = 0, x = 0; x < array_x; x++)
272 {
273 for (int y = 0; y < array_y; y++)
274 {
275 if (bucket[x, y] == 0) continue;
276 arry[o++] = bucket[x, y];
277 }
278 }
279 }
280
281 }
282
283 }
各排序演算法時間複雜度與空間複雜度
相關文章
- 【資料結構】 各種排序演算法的實現資料結構排序演算法
- 【資料結構與演算法】內部排序總結（附各種排序演算法原始碼）資料結構演算法排序原始碼
- javascript排序各種演算法例項程式碼JavaScript排序演算法
- 用 python 實現各種排序演算法Python排序演算法
- 六種排序演算法的JavaScript實現以及總結排序演算法JavaScript
- 各種排序演算法思想複雜度及其java程式實現排序演算法複雜度Java
- JS的各種排序演算法實現--暫時不懂JS排序演算法
- PHP 四種基本排序演算法的程式碼實現PHP排序演算法
- 常見排序演算法原理及JS程式碼實現排序演算法JS
- 程式猿的年終總結，各種版本各種殘
- C#各種加密方法，字典排序C#加密排序
- 排序演算法分析總結（附js實現）排序演算法JS
- 排序演算法總結(基於Java實現)排序演算法Java
- 全面瞭解歸併排序演算法及程式碼實現排序演算法
- 十大經典排序演算法最強總結（含JAVA程式碼實現）排序演算法Java
- PHP 排序演算法原理及總結PHP排序演算法
- 【資料結構與演算法】快速排序（三種程式碼實現以及工程優化）資料結構演算法排序優化
- 幾種常見排序演算法總結排序演算法
- 排序演算法原理總結和Python實現排序演算法Python
- C#常用8種排序演算法實現以及原理簡介C#排序演算法
- 面試必備：八種排序演算法原理及Java實現面試排序演算法Java
- 幾種常見的排序演算法總結排序演算法
- 5種排序演算法效能比較總結排序演算法
- 複習資料結構：排序演算法（五）——快速排序的各種版本資料結構排序演算法
- Python各種排序演算法整理Python排序演算法
- 各類排序演算法的c++實現排序演算法C++
- 資料結構-各種排序演算法效率對比圖資料結構排序演算法
- php實現4種排序演算法PHP排序演算法
- js實現資料結構及演算法之排序演算法JS資料結構演算法排序
- Android中使用程式碼截圖的各種方法總結Android
- **超詳細的**10種排序演算法原理及 JS 實現排序演算法JS
- 演算法-排序演算法思想及實現演算法排序
- 排序演算法總結排序演算法
- 總結logminer使用及各種問題處理
- #排序演算法#【6】排序演算法總結排序演算法
- 菜鳥必看的排序演算法(簡單通俗)及程式碼實現，幾張圖帶你吃透排序演算法排序演算法
- 九種排序演算法的 JavaScript 實現排序演算法JavaScript
- JavaScript實現的7種排序演算法JavaScript排序演算法