一、冒泡排序
1、算法思想
冒泡排序是一種簡單的排序算法，通過循環遍歷，將臨近的兩個元素進行比較，滿足排序規則時，進行下一組元素對比，當不滿足排序規則時，將兩個元素交換位置，再繼續進行下一組元素對比，確保最大的元素在一遍循環過後一定排在最後面，然後最後通過最多n2次循環對比，直到完全有序。
2、算法描述
（1）比較兩個相鄰的元素，如果第一個比第二個大，那麼就交換他們的位置。
（2）重複步驟（1）的操作，依次比較兩兩相鄰的兩個元素。所有元素對比過後表示一次循環結束。
（3）至多循環n-1次，重複上面兩個步驟。
（4）直到沒有任何一組元素需要交換位置表示排序完成。
3、代碼實現
void BubbleSort(int* slist,int length)
{
int temp;
for (int i = 0; i < length - 1; i++)
{
for (int j = 0; j < length - 1 - i; j++)
{
if (slist[j] > slist[j + 1])
{
temp = slist[j];
slist[j] = slist[j + 1];
slist[j + 1] = temp;
}
}
}
}
int main()
{
int sortlist[] = { 5,0,4,1,8,3,7 };
BubbleSort(sortlist,7);
}
4、算法複雜度
最好的情況爲正序，只需要一遍遍歷，所以時間複雜度爲O(n),最壞的情況爲逆序，需要遍歷n2次，所以時間複雜度爲O(n2)。由於只有一個交換的變量temp需要內存，所以空間複雜度爲O(1)。
二、插入排序
1、算法思想
將列表中的每個元素依次和之前排好序的元素進行比較，找到合適的位置插入，使之前有序的列表保持依然有序。
2、算法描述
（1）從第2個元素開始，選取第2個元素（i），認爲第1個元素爲一個只有一個元素的有序列表。
（2）將選取的元素與之前的元素依次比較，如果選取的元素小於於列表中的元素，交換他們的位置。
（3）選取下一個元素（i+1），重複步驟（2），直至列表中的每個元素都進行了步驟（2）的操作。
3、代碼實現
//方法一
void InsertSort1(int* slist,int length)
{
int temp;
for (int i = 1; i < length; i++)
{
int j = i -1;
while (slist[j] > slist[j+1] && j >= 0)
{
//交換位置
temp = slist[j];
slist[j] = slist[j+1];
slist[j+1] = temp;
j--;
/*或者這樣交換*/
// slist[j+1] = slist[j] + slist[j+1];
// slist[j] = slist[j+1] - slist[j];
// slist[j+1] = slist[j+1] - slist[j];
// j--;
}
}
}
//方法二
void InsertSort2(int* slist,int length)
{
for (int i = 1; i < length; i++)
{
int j = i - 1;
int number = slist[i];
while (j >= 0 && slist[j] > number)
{
slist[j+1] = slist[j];
j--;
}
slist[j+1] = number;
}
}
4、算法複雜度
最好的情況爲正序，只需要一遍遍歷，所以時間複雜度爲O(n),最壞的情況爲逆序，需要遍歷n2次，所以時間複雜度爲O(n2)。空間複雜度爲O(1)。
三、選擇排序
1、算法思想
從頭開始，遍歷列表找到最小值，把最小的值放在第一個位置，在遍歷找到第二小的值放在第一個後面，以此類推，知道最後一個排好序。
2、算法描述
（1）遍歷整個列表N個元素，找到最小的元素，與第一個元素交換位置。
（2）遍歷剩餘的N-1個元素，找到最小的元素，將它排在剩餘N-1個元素的第一個。
（3）以此類推，重複步驟（2），直到N-1小於1。
3、代碼實現
void SelectSort(int* slist, int length)
{
int min;
int temp;
for (int i = 0; i < length; i++)
{
min = i;
for (int j = i + 1; j < length; j++)
{
if (slist[j] < slist[min])
{
min = j;
}
}
temp = slist[i];
slist[i] = slist[min];
slist[min] = temp;
}
}
4、算法複雜度
不管最後還是最壞的情況，選擇排序的時間複雜度都是O(n2)，空間複雜度爲O(1)。
四、歸併排序
1、算法思想
歸併排序採用分治的思想，將一個列表分爲多個子列表，每個子序列是有序的。然後再把有序子序列合併爲整體有序序列。
2、算法描述
（1）將列表元素對半分開，分爲兩個列表。
（2）重複步驟（1），直至每個列表只有一個元素。
（3）將兩個相鄰的列表排序，直至真個列表有序。
3、代碼實現
//排序
void MergeSort(int sourceArr[], int tempArr[], int startIndex, int midIndex, int endIndex)
{
//i:第一個待排序的起始位置，
int i = startIndex;
//j:第二個待排序的起始位置，
int j = midIndex + 1;
int k = startIndex;
while (i != midIndex + 1 && j != endIndex+1)
{
if (sourceArr[i] > sourceArr[j])
{
tempArr[k] = sourceArr[j];
k++;
j++;
}
else
{
tempArr[k] = sourceArr[i];
k++;
i++;
}
}
//將兩個中未排序的添加到tempArr中
while (i != midIndex + 1)
{
tempArr[k] = sourceArr[i];
i++;
k++;
}
//將兩個中未排序的添加到tempArr中
while (j != endIndex+1)
{
tempArr[k] = sourceArr[j];
j++;
k++;
}
//將tempArr中的元素賦值給sourceArr
for (int i = startIndex; i <= endIndex; i++)
{
sourceArr[i] = tempArr[i];
}
}
//分解遞歸
void BranchSort(int sourceArr[], int tempArr[], int startIndex, int endIndex)
{
if (startIndex < endIndex)
{
int mid = startIndex + (endIndex - startIndex) / 2;
BranchSort(sourceArr, tempArr, startIndex, mid);
BranchSort(sourceArr, tempArr, mid+1, endIndex);
MergeSort(sourceArr, tempArr, startIndex, mid, endIndex);
}
}
4、算法複雜度
歸併排序是穩定排序算法，假設數組長度爲n，那麼拆分數組共需logn, 又每步都是一個普通的合併子數組的過程，時間複雜度爲O(n)， 故其綜合時間複雜度爲O(nlogn)。另一方面， 歸併排序多次遞歸過程中拆分的子數組需要保存在內存空間， 其空間複雜度爲O(n)。
五、希爾排序
1、算法思想
希爾排序，也稱遞減增量排序算法。將整個列表根據增量分爲若干個子列表分別進行插入排序。隨着增量的減小，列表趨於基本有序，當增量爲1時，相當再做一次插入排序，使列表有序。
2、算法描述
（1）選擇一個增量gap，一般爲列表長度的一半。
（2）將列表中元素下標每隔gap的元素組成一個新的子列表。
（3）對每個子列表進行插入排序。
（4）將gap去原來的一半，重複步驟（2）（3），直到gap小於1。
3、代碼實現
void ShellSort(int* slist, int length)
{
int temp;
//gap爲增量，一般取長度的一般
int gap = length / 2;
//當增量小於1時結束排序
while (gap >= 1)
{
//最多分爲gap個列表
for (int i = 0; i < gap; i++)
{
//下面的代碼爲一個簡單的插入排序，只是插入排序的數組下標每次移動的不是1而是gap
for (int j = i+gap; j < length; j = j + gap)
{
if (slist[j] < slist[j-gap])
{
int k = j - gap;
int temp = slist[j];
while (k >= 0 && slist[k] > temp)
{
slist[k + gap] = slist[k];
k = k - gap;
}
slist[k+gap] = temp;
}
}
}
//增量遞減
gap = gap/ 2;
}
}
4、算法複雜度
希爾排序是不穩定的排序，它時間複雜度和步長的選擇有關。
看如下兩個增量序列：
n/2、n/4、n/8...1
1 、3 、7 ...2^k-1
第一個序列稱爲希爾增量序列，使用希爾增量時，希爾排序在最壞情況下的時間複雜度爲O(n2)。
第二個序列稱爲Hibbard增量序列，使用Hibbard增量時，希爾排序在最壞情況下的時間複雜度爲O(n3/2)。
六、快速排序
1、算法思想
快速排序採用分治的思想，通通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以 遞歸 進行，以此達到整個數據變成有序序列。
2、算法描述
（1）選定一個基準元素
（2）從右往左找到比基準元素小的元素
（3）從左往右找到比基準元素大的元素
（4）交換左右找到的兩個元素的位置
（5）重複上面（2）（3）（4）步，直至左右兩個元素相遇。
3、代碼實現
void QuickSort(int* slist, int left, int right)
{
if (left >= right)
{
return;
}
int i = left;
int j = right;
int key = slist[left];
int temp;
//直到遍歷完整個列表
while (i < j)
{
//從右到左找到小於key的下標
while (i<j&&slist[j] >= key)
{
j--;
}
//從左到右找到大於key的下標
while (i<j && slist[i] <= key)
{
i++;
}
//交換找到的兩個元素,保證小的元素在前，大的元素在後
if (i < j)
{
temp = slist[i];
slist[i] = slist[j];
slist[j] = temp;
}
}
//將key元素交換到中間，確保分爲大小兩個列表
temp = slist[left];
slist[left] = slist[j];
slist[j] = temp;
QuickSort(slist, left, j - 1);
QuickSort(slist, j + 1, right);
}
void QuickSort2(int* slist, int left, int right)
{
if (left >= right)
{
return;
}
int j = left-1;
int key = slist[right];
int temp;
for (int i = left; i < right; i++)
{
//遍歷整個列表，找到小於key的元素個數，並且通過交換位置，讓他們的下標都在j的前面
if (slist[i] < key)
{
j++;
if (i != j)
{
temp = slist[i];
slist[i] = slist[j];
slist[j] = temp;
}
}
}
//將key的位置與j+1的位置互換，保證將slist列表分爲小於slist[j+1]與大於slist[j+1]的兩個列表
slist[right] = slist[j + 1];
slist[j + 1] = key;
QuickSort2(slist,left,j);
QuickSort2(slist, j+2, right);
}
4、算法複雜度
快速排序之所比較快，因爲相比冒泡排序，每次交換是跳躍式的。每次排序的時候設置一個基準點，將小於等於基準點的數全部放到基準點的左邊，將大於等於基準點的數全部放到基準點的右邊。這樣在每次交換的時候就不會像冒泡排序一樣每次只能在相鄰的數之間進行交換，交換的距離就大的多了。因此總的比較和交換次數就少了，速度自然就提高了。當然在最壞的情況下，仍可能是相鄰的兩個數進行了交換。因此快速排序的最差時間複雜度和冒泡排序是一樣的都是O(N2)，它的平均時間複雜度爲O(NlogN)。
七、堆排序
堆排序實際上是利用堆的性質來進行排序的，要知道堆排序的原理我們首先一定要知道什麼是堆。
堆的定義：
堆實際上是一棵完全二叉樹。
堆滿足兩個性質:
1、堆的每一個父節點都大於（或小於）其子節點；
2、堆的每個左子樹和右子樹也是一個堆。
堆的分類：
堆分爲兩類：
1、最大堆（大頂堆）：堆的每個父節點都大於其孩子節點；
2、最小堆（小頂堆）：堆的每個父節點都小於其孩子節點；
堆的存儲：
一般都用數組來表示堆，i結點的父結點下標就爲(i – 1) / 2。它的左右子結點下標分別爲2 * i + 1和2 * i + 2。如下圖所示：
堆排序：
由上面的介紹我們可以看出堆的第一個元素要麼是最大值（大頂堆），要麼是最小值（小頂堆），這樣在排序的時候（假設共n個節點），直接將第一個元素和最後一個元素進行交換，然後從第一個元素開始進行向下調整至第n-1個元素。所以，如果需要升序，就建一個大堆，需要降序，就建一個小堆。
堆排序的步驟分爲三步:
1、建堆（升序建大堆，降序建小堆）；
2、交換數據；
3、向下調整。
假設我們現在要對數組arr[]={8,5,0,3,7,1,2}進行排序（降序）：
首先要先建小堆：
堆建好了下來就要開始排序了：
現在這個數組就已經是有序的了。
算法實現：
1 //堆排序
2 /*
3 大頂堆sort之後，數組爲從小到大排序
4 */
5 //====調整=====
6 void AdjustHeap(int* h, int node, int len) //----node爲需要調整的結點編號，從0開始編號;len爲堆長度
7 {
8 int index=node;
9 int child=2*index+1; //左孩子，第一個節點編號爲0
10 while(child<len)
11 {
12 //右子樹
13 if(child+1<len && h[child]<h[child+1])
14 {
15 child++;
16 }
17 if(h[index]>=h[child]) break;
18 Swap(h[index],h[child]);
19 index=child;
20 child=2*index+1;
21 }
22 }
23
24
25 //====建堆=====
26 void MakeHeap(int* h, int len)
27 {
28 for(int i=len/2;i>=0;--i)
29 {
30 AdjustHeap(h, i, len);
31 }
32 }
33
34 //====排序=====
35 void HeapSort(int* h, int len)
36 {
37 MakeHeap(h, len);
38 for(int i=len-1;i>=0;--i)
39 {
40 Swap(h[i],h[0]);
41 AdjustHeap(h, 0, i);
42 }
43 }
八、基數排序
基數排序與本系列前面講解的七種排序方法都不同，它不需要比較關鍵字的大小。
它是根據關鍵字中各位的值，通過對排序的N個元素進行若干趟“分配”與“收集”來實現排序的。
1.LSD(低位到高位的排序)
不妨通過一個具體的實例來展示一下，基數排序是如何進行的。
設有一個初始序列爲: R {50, 123, 543, 187, 49, 30, 0, 2, 11, 100}。
我們知道，任何一個阿拉伯數，它的各個位數上的基數都是以0~9來表示的。
所以我們不妨把0~9視爲10個桶。
我們先根據序列的個位數的數字來進行分類，將其分到指定的桶中。例如：R[0] = 50，個位數上是0，將這個數存入編號爲0的桶中。
分類後，我們在從各個桶中，將這些數按照從編號0到編號9的順序依次將所有數取出來。
這時，得到的序列就是個位數上呈遞增趨勢的序列。
按照個位數排序：
{50, 30, 0, 100, 11, 2, 123, 543, 187, 49}
接下來，可以對十位數、百位數也按照這種方法進行排序，最後就能得到排序完成的序列。
LSD 算法實現：
1 int GetMaxDight(int* h, int len)
2 {
3 if(h==NULL) return 0;
4 if(len<1) return 0;
5
6 int max=h[0];
7 for(int i=1;i<len;++i)
8 {
9 if(h[i]>max) max=h[i];
10 }
11
12 int digit=1;
13 while(max/10!=0)
14 {
15 max/=10;
16 ++digit;
17 }
18
19 return digit;
20 }
21
22 int GetReminder(int value,int digit)
23 {
24 int div=1;
25 for(int i=1;i<digit;++i)
26 div*=10;
27
28 return value/div%10;
29 }
30
31 void RadixSort_LSD(int* h, int len)
32 {
33 if(h==NULL) return;
34 if(len<=1) return;
35
36 int digit=GetMaxDight(h,len);
37 //printf("MaxDigit:%d\n", digit);
38
39 int count[10]={0};
40 int *tmp=(int*)calloc(len,sizeof(int));
41
42 for(int d=1;d<=digit;++d)
43 {
44 memset(count,0,sizeof(count));
45
46 for(int i=0;i<len;++i)
47 {
48 count[GetReminder(h[i],d)]++;
49 }
50
51 //求右邊界
52 for(int i=1;i<10;++i)
53 {
54 count[i]+=count[i-1];
55 }
56
57 for(int i=len-1;i>=0;--i)
58 {
59 int r=GetReminder(h[i],d);
60 int index=count[r];
61 tmp[index-1]=h[i];
62 count[r]--;
63 }
64
65 memcpy(h,tmp,len*sizeof(int));
66 }
67
68 free(tmp);
69 }
70
71 void RadixSort_LSD_Reverse(int* h, int len)
72 {
73 if(h==NULL) return;
74 if(len<=1) return;
75
76 int digit=GetMaxDight(h,len);
77 //printf("MaxDigit:%d\n", digit);
78
79 int count[10]={0};
80
81 int *tmp=(int*)calloc(len,sizeof(int));
82
83 for(int d=1;d<=digit;++d)
84 {
85 memset(count,0,sizeof(count));
86
87 for(int i=0;i<len;++i)
88 {
89 count[GetReminder(h[i],d)]++;
90 }
91
92 //printf("haha\n");
93
94 //求右邊界
95 for(int i=8;i>=0;--i)
96 {
97 count[i]+=count[i+1];
98 }
99
100
101
102 for(int i=len-1;i>=0;--i)
103 {
104 int r=GetReminder(h[i],d);
105 int index=count[r];
106 tmp[index-1]=h[i];
107 count[r]--;
108 }
109
110 memcpy(h,tmp,len*sizeof(int));
111 }
112
113 free(tmp);
114 }
2.MSD(高位到低位排序)
下面我們直接來介紹MSD基數排序的步驟。
MSD基數排序是從最高位開始對序列進行分組，到最低位爲止。但是其實現過程是和LSD基數排序不同的，排序過程中需要用到遞歸函數。
待排序序列
170, 45, 75, 90, 2, 24, 802, 66
我們看到，這裏面的最大的數是3位數。所以說我們開始從百位對這些數進行分組
0: 045, 075, 090,002, 024, 066
1: 170
2-7: 空
8: 802
9: 空
從這裏開始就和LSD基數排序有差別了。在LSD基數排序中，每次分好組以後開始對桶中的數據進行收集。然後根據下一位，對收集後的序列進行分組。而對於MSD，在這裏不會對桶中的數據進行收集。我們要做的是檢測每個桶中的數據。當桶中的元素個數多於1個的時候，要對這個桶遞歸進行下一位的分組。
在這個例子中，我們要對0桶中的所有元素根據十位上的數字進行分組
0: 002
1: 空
2: 024
3: 空
4: 045
5: 空
6: 066
7: 075
8: 空
9: 090
按照上面所說，我們應該再遞歸的對每個桶中的元素根據個位上的數進行分組。但是我們發現，現在在每個桶中的元素的個數都是小於等於1的。因此，到這一步我們就開始回退了。也就是說我們開始收集桶中的數據。收集完成以後，回退到上一層。此時按照百位進行分組的桶變成了如下的形式
0: 002, 024, 045,066, 075, 090
1: 170
2-7: 空
8: 802
9: 空
然後我們在對這個桶中的數據進行收集。收集起來以後序列如下
2, 24, 45, 66, 75, 90, 170, 802
整個MSD基數排序就是按照上面的過程進行的。
在我對MSD基數排序步驟進行敘述的時候，中間遞歸函數的過程可能敘述的不夠清楚。我個人建議對遞歸函數不瞭解的可以先了解一下遞歸函數的原理，然後再回來看這個過程可能對MSD基數排序過程更容易理解。
算法實現：
1 int GetMaxDight(int* h, int len)
2 {
3 if(h==NULL) return 0;
4 if(len<1) return 0;
5
6 int max=h[0];
7 for(int i=1;i<len;++i)
8 {
9 if(h[i]>max) max=h[i];
10 }
11
12 int digit=1;
13 while(max/10!=0)
14 {
15 max/=10;
16 ++digit;
17 }
18
19 return digit;
20 }
21
22 int GetReminder(int value,int digit)
23 {
24 int div=1;
25 for(int i=1;i<digit;++i)
26 div*=10;
27
28 return value/div%10;
29 }
30
31 void RRadixSort_MSD(int* h, int begin, int end, int digit)
32 {
33 if(h==NULL) return;
34 if(begin>=end) return;
35 if(digit<1) return;
36
37 int start[10];
38 int count[10]={0};
39 int *tmp=(int*)calloc(end-begin+1,sizeof(int));
40
41 for(int i=begin;i<=end;++i)
42 {
43 count[GetReminder(h[i],digit)]++;
44 }
45
46 memcpy(start,count,sizeof(start));
47
48 //求右邊界
49 for(int i=1;i<10;++i)
50 {
51 start[i]+=start[i-1];
52 }
53
54 for(int i=end;i>=begin;--i)
55 {
56 int r=GetReminder(h[i],digit);
57 int index=start[r];
58 tmp[index-1]=h[i];
59 start[r]--;
60 }
61
62 /*
63 for(int i=0;i<10;++i)
64 {
65 printf("%d ",start[i]);
66 }
67
68 printf("\n");
69 */
70
71 memcpy(&h[begin],tmp,(end-begin+1)*sizeof(int));
72
73 for(int i=0;i<10;++i)
74 {
75 if(count[i]>1)
76 {
77 RRadixSort_MSD(h, start[i], start[i]+count[i]-1, digit-1);
78 }
79 }
80 }
81
82 void RadixSort_MSD(int* h, int len)
83 {
84 if(h==NULL) return;
85 if(len<=1) return;
86
87 int digit=GetMaxDight(h,len);
88
89 //printf("MaxDigit:%d\n",digit);
90
91 RRadixSort_MSD(h, 0, len-1, digit);
92 }
93
94 void RRadixSort_MSD_Reverse(int* h, int begin, int end, int digit)
95 {
96 if(h==NULL) return;
97 if(begin>=end) return;
98 if(digit<1) return;
99
100 int start[10];
101 int count[10]={0};
102 int *tmp=(int*)calloc(end-begin+1,sizeof(int));
103
104 for(int i=begin;i<=end;++i)
105 {
106 count[GetReminder(h[i],digit)]++;
107 }
108
109 memcpy(start,count,sizeof(start));
110
111 //求右邊界
112 for(int i=8;i>=0;--i)
113 {
114 start[i]+=start[i+1];
115 }
116
117 for(int i=end;i>=begin;--i)
118 {
119 int r=GetReminder(h[i],digit);
120 int index=start[r];
121 tmp[index-1]=h[i];
122 start[r]--;
123 }
124
125 /*
126 for(int i=0;i<10;++i)
127 {
128 printf("%d ",start[i]);
129 }
130
131 printf("\n");
132 */
133
134 memcpy(&h[begin],tmp,(end-begin+1)*sizeof(int));
135
136 for(int i=0;i<10;++i)
137 {
138 if(count[i]>1)
139 {
140 RRadixSort_MSD_Reverse(h, start[i], start[i]+count[i]-1, digit-1);
141 }
142 }
143 }
144
145 void RadixSort_MSD_Reverse(int* h, int len)
146 {
147 if(h==NULL) return;
148 if(len<=1) return;
149
150 int digit=GetMaxDight(h,len);
151
152 //printf("MaxDigit:%d\n",digit);
153
154 RRadixSort_MSD_Reverse(h, 0, len-1, digit);
155 }
算法比較
