轉載自：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）、

建堆是一個從下往上進行“篩選”的過程