轉載自：https://blog.csdn.net/jkdd123456/article/details/83096684
一：幾種排序方法
排序算法的複雜度：
ACM常用算法排序
二、
1、冒泡排序：
冒泡排序是一種簡單的排序算法，但是時間複雜度較大。它重複地走訪過要排序的數列，一次比較兩個元素，如果它們的順序錯誤就把它們交換過來。走訪數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個算法的名字由來是因爲越小的元素會經由交換慢慢“浮”到數列的頂端。
：算法描述
（1）、比較相鄰的元素。如果第一個比第二個大，就交換它們兩個；
（2）、對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對，這樣在最後的元素應該會是最大的數；
（3）、針對所有的元素重複以上的步驟，除了最後一個；
（4）、重複步驟1~3，直到排序完成。
3：動畫演示
4：核心CODE:
int BubbleSort(int arr[],int len) {
for (int i = 0; i < len - 1; i++) {
for (int j = 0; j < len - 1 - i; j++) {
if (arr[j] > arr[j+1]) { // 相鄰元素兩兩對比
int temp = arr[j+1]; // 元素交換
arr[j+1] = arr[j];
arr[j] = temp;
}
}
}
return arr;
}
三、
1：選擇排序：
選擇排序(Selection-sort)是一種簡單直觀的排序算法。
用 pos 變量記錄位置，每次在找完最小（大）元素之後與 pos 位置的元素交換
它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然後，再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。
2：算法描述
（1）、初始狀態：無序區爲R[1…n]，有序區爲空；
（2）、第i趟排序(i=1,2,3…n-1)開始時，當前有序區和無序區分別爲R[1…i-1]和R(i…n）。該趟排序從當前無序區中-選出關鍵字最 小的記錄 R[k]，將它與無序區的第1個記錄R交換，使R[1…i]和R[i+1…n)分別變爲記錄個數增加1個的新有序區和記錄個數減 少1個的新無序區；
（3）、 n-1趟結束，數組有序化了。
3：動畫演示
4：核心CODE:
int selectionSort(int arr[], int len) {
int minIndex, temp;
for (int i = 0; i < len - 1; i++) {
minIndex = i;
for (int j = i + 1; j < len; j++) {
if (arr[j] < arr[minIndex]) { // 尋找最小的數
minIndex = j; // 將最小數的索引保存
}
}
temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
return arr;
}
四：
1：插入排序
插入排序（Insertion-Sort）的算法描述是一種簡單直觀的排序算法。它的工作原理是通過構建有序序列，對於未排序數據，在已排序序列中從後向前掃描，找到相應位置並插入。
2：算法描述
（1）、從第一個元素開始，該元素可以認爲已經被排序；
（2）、取出下一個元素，在已經排序的元素序列中從後向前掃描；
（3）、如果該元素（已排序）大於新元素，將該元素移到下一位置；
（4）、重複步驟3，直到找到已排序的元素小於或者等於新元素的位置；
（5）、將新元素插入到該位置後；
（6）、重複步驟2~5。
3：動畫演示
4：核心CODE：
int insertionSort(int arr[] ,int len) {
int preIndex, current;
for (int i = 1; i < len; i++) {
preIndex = i - 1;
current = arr[i];
while (preIndex >= 0 && arr[preIndex] > current) {
arr[preIndex + 1] = arr[preIndex];
preIndex–;
}
arr[preIndex + 1] = current;
}
return arr;
}
五：
1：合併排序（歸併排序）
合併操作(merge)，是採用分治法（Divide and Conquer）的一個非常典型的應用。
將已有序的子序列合併，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合併成一個有序表，稱爲2-路歸併。
合併排序組主要是兩個步驟： 分 + 治（合併）
2：算法描述
（1）、把長度爲n的輸入序列分成兩個長度爲n/2的子序列；
（2）、對這兩個子序列分別採用歸併排序；
（3）、將兩個排序好的子序列合併成一個最終的排序序列。
歸併排序採用的是遞歸的方式，每次對區間進行遞歸，每個區間又可以分爲左右區間，執行完左區間之後，執行右區間
3：動畫演示
4：核心CODE：
// b數組作爲臨時數組，當比較的時候，存放值
void Merge(LL first,LL mid,LL last)
{
LL be=first;
LL en=mid;
LL be1=mid+1;
LL en1=last;
LL flag=0;
while(be<=en&&be1<=en1)
{
if(a[be]<=a[be1])
b[flag++]=a[be++];
else
{
b[flag++]=a[be1++];
}
}
if(be<=en)
{
for(LL i=be;i<=en;i++)
b[flag++]=a[i];
}
if(be1<=en1)
{
for(LL i=be1;i<=en1;i++)
b[flag++]=a[i];
}
for(LL i=0;i<flag;i++) // 把b數組中的數賦值給a數組，最後a數組裏存的是排好序之後的數
a[first++]=b[i];
}
void merge_sort(LL first,LL last)
{
LL mid;
if(first<last)
{
mid=(first+last)/2;
merge_sort(first,mid);
merge_sort(mid+1,last);
Merge(first,mid,last);
}
}
六：
1、快速排序
快速排序的基本思想：通過一趟排序將待排記錄分隔成獨立的兩部分，其中一部分記錄的關鍵字均比另一部分的關鍵字小，則可分別對這兩部分記錄繼續進行排序，以達到整個序列有序。
2：算法描述
快速排序使用分治法來把一個串（list）分爲兩個子串（sub-lists）。具體算法描述如下：
（1）、從數列中挑出一個元素，稱爲 “基準”（pivot），一般是第一個元素；
（2）、重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面
（相同的數可以到任一邊）。在這個分區退出之後，該基準就處於數列的中間位置。這個稱爲分區（partition）操作；
（3）、遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。
3：
一趟快速排序（一次劃分）
目標：找一個記錄，以它的關鍵字作爲“樞軸”，凡其關鍵字小於樞軸的記錄均移動至該記錄之前，反之，凡關鍵字大於樞軸的記錄均移動至該記錄之後。
致使一趟排序之後，記錄的無序序列R[s…t]將分割成兩部分：R[s…i-1] 和 R[i+1…t], R[j]≤ R[i] ≤ R[j] (s≤j≤i-1) 樞軸 (i+1≤j≤t)
首先對無序的記錄序列進行“一次劃分”，之後分別對分割所得兩個子序列“遞歸”進行快速排序。
例如：
設 R[s]=52 爲樞軸暫存在R[0]的位置上
將 R[high] 和 樞軸的關鍵字進行比較，要求R[high] ≥ 樞軸的關鍵字
將 R[low] 和 樞軸的關鍵字進行比較，要求R[low]≤ 樞軸的關鍵字
可見，經過“一次劃分” ，將關鍵字序 52, 49, 80, 36, 14, 58, 61, 97, 23, 75
調整爲: 23, 49, 14, 36, (52) 58, 61, 97, 80, 75
在調整過程中，設立了兩個指針: low 和high，它們的初值分別爲: s 和 t, 之後逐漸減小 high，增加 low，並保證
R[high]≥52，和 R[low]≤52,否則進行記錄的“交換”。
4：動畫描述
5：核心CODE：
進行分區操作
int partition(int low,int high)
{
a[0]=a[low];
pivotker=a[low];
while(low<high)
{
while(low<high&&a[high]>=pivotkey)
--high;
a[low]=a[high];
while(low<high&&a[low]<=pivotkey)
++low;
a[high]=a[low];
}
a[low]=a[0];
}
七、堆排序
1：堆排序
堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序算法。堆積是一個近似完全二叉樹的結構，並同時滿足堆積的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。
2：算法描述
（1）、將初始待排序關鍵字序列(R1,R2….Rn)構建成大頂堆或者小頂堆，此堆爲初始的無序區；
（2）、將堆頂元素R[1]與最後一個元素R[n]交換，此時得到新的無序區(R1,R2,……Rn-1)和新的有序區(Rn),
且滿足R[1,2…n-1]<=R[n]；
（3）、由於交換後新的堆頂R[1]可能違反堆的性質，因此需要對當前無序區(R1,R2,……Rn-1)調整爲新堆，然後再次將R[1]與無序區最後一個元素交換，得到新的無序區(R1,R2….Rn-2)和新的有序區(Rn-1,Rn)。不斷重複此過程直到有序區的元素個數爲n-1，則整個排序過程完成。
堆是滿足下列性質的數列{r1, r2, …，rn}：
小頂堆
大頂堆
例如
{12, 36, 27, 65, 40, 34, 98, 81, 73, 55, 49} 是小頂堆
{12, 36, 27, 65, 40, 14, 98, 81, 73, 55, 49} 不是堆
3：若將該數列視作完全二叉樹，
則 r2i 是 ri 的左孩子; r2i+1 是 ri 的右孩子。
4：動畫演示
5：
堆排序即是利用 堆 的特性對記錄序列進行排序的一種排序方法。
6:
定義堆的類型：
typedef SqList HeapType;
// 堆採用順序表表示
兩個問題：
如何篩選？ 如何建堆？
(1)、
所謂“篩選”指的是，對一棵左/右子樹 均爲堆的完全二叉樹，“調整”根結點使整個二叉樹也成爲一個堆。
（2）、
建堆是一個從下往上進行“篩選”的過程