單鏈表的冒泡，快排，選擇，插入，歸併等多圖詳解
阿新 • • 發佈：2020-12-16
上節介紹了連結串列的基本操作[史上最全單鏈表的增刪改查反轉等操作彙總以及5種排序演算法(C語言)]()
這節介紹連結串列的5種排序演算法。
@[TOC]
### 0.穩定排序和原地排序的定義
**穩定排序**：
假定在待排序的記錄序列中，存在多個具有相同的關鍵字的記錄，若經過排序，這些記錄的**相對次序保持不變**，即在原序列中，ri=rj，且ri在rj之前，而在排序後的序列中，ri仍在rj之前，則稱這種排序演算法是穩定的；否則稱為不穩定的。像**氣泡排序**，**插入排序**，**基數排序**，**歸併排序**等都是穩定排序
**原地排序**：
基本上**不需要額外輔助的的空間，允許少量額外的輔助變數**進行的排序。就是在原來的排序陣列中比較和交換的排序。像**選擇排序**，**插入排序**，**希爾排序**，**快速排序**，**堆排序**等都會有一項比較且交換操作(swap(i,j))的邏輯在其中，因此他們都是屬於原地(原址、就地)排序，而合併排序，計數排序，基數排序等不是原地排序
### 1.氣泡排序
**基本思想:**
把第一個元素與第二個元素比較，如果第一個比第二個大，則交換他們的位置。接著繼續比較第二個與第三個元素，如果第二個比第三個大，則交換他們的位置....
我們對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對，這樣一趟比較交換下來之後，排在最右的元素就會
是最大的數。除去最右的元素，我們對剩餘的元素做同樣的工作，如此重複下去，直到排序完成。
**具體步驟**：
1.比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
2.對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素會是最大的數。
3.針對所有的元素重複以上的步驟，除了最後一個。
4.持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。
**時間複雜度**：O(N2)
**空間複雜度**：O(1)
**穩定排序**:是
**原地排序**:是
```c
Node *BubbleSort(Node *phead)
{
Node * p = phead;
Node * q = phead->next;
/*有幾個資料就-1；比如x 個idata>q->data)
{
/*頭結點和下一節點的交換，要特殊處理，更新新的頭head*/
if (p == phead)
{
p->next = q->next;
q->next = p;
head = q;
phead = q;
/*這裡切記要把p,q換回來，正常的話q應該在p的前面，進行的是p,q的比較
*但是經過指標域交換之後就變成q,p.再次進行下一次比較時，
*就會變成q,p的資料域比較。假如原本p->data > q->data,則進行交換。變成q->data和p->data比較，
*不會進行交換，所以排序就會錯誤。有興趣的可以除錯下。
*/
Node*temp=p;
p=q;
q=temp;
}
/*處理中間過程，其他資料的交換情況，要尋找前驅節點if (p != phead)*/
else
{
/*p，q的那個在前，那個在後。指標域的連線畫圖好理解一點*/
if (p->next == q)
{
/*尋找p的前驅節點*/
Node *ppre = FindPreNode(p);
/*將p的下一個指向q的下一個*/
p->next = q->next;
/*此時q為頭結點，讓q的下一個指向p，連線起來*/
q->next = p;
/*將原來p的前驅節點指向現在的q，現在的q為頭結點*/
ppre->next = q;
Node*temp=p;
p=q;
q=temp;
}
else if (q->next == p)
{
Node *qpre = FindPreNode(q);
q->next = p->next;
p->next = q;
qpre->next = p;
Node*temp=p;
p=q;
q=temp;
}
}
}
/*地址移動*/
p = p->next;
q = q->next;
}
/*進行完一輪比較後，從頭開始進行第二輪*/
p = phead;
q = phead->next;
}
head = phead;
return head;
}
```
### 2.快速排序
**基本思想**
我們從陣列中選擇一個元素，我們把這個元素稱之為中軸元素吧，然後把陣列中所有小於中軸元素的元素放在其左邊，
所有大於或等於中軸元素的元素放在其右邊，顯然，此時中軸元素所處的位置的是有序的。也就是說，我們無需再移動中軸
元素的位置。
從中軸元素那裡開始把大的陣列切割成兩個小的陣列(兩個陣列都不包含中軸元素)，接著我們通過遞迴的方式，讓中軸元素
左邊的陣列和右邊的陣列也重複同樣的操作，直到陣列的大小為1，此時每個元素都處於有序的位置。
**具體步驟**：
1.從數列中挑出一個元素，稱為 "基準"（pivot）;
2.重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分割槽退出之後，該基準就處於數列的中間位置。這個稱為分割槽（partition）操作；
3.遞迴地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序；
**時間複雜度**：O(NlogN)
**空間複雜度**：O(logN)
**穩定排序**：否
**原地排序**：是
```c
int *QuickSort(Node* pBegin, Node* pEnd)
{
if(pBegin == NULL || pEnd == NULL || pBegin == pEnd)
return 0;
//定義兩個指標
Node* p1 = pBegin;
Node* p2 = pBegin->next;
int pivot = pBegin->data;
//每次只比較小的，把小的放在前面。經過一輪比較後，被分成左右兩部分。其中p1指向中值處，pbegin為pivot。
while(p2 != NULL)/* && p2 != pEnd->next */
{
if(p2->data < pivot)
{
p1 = p1->next;
if(p1 != p2)
{
SwapData(&p1->data, &p2->data);
}
}
p2 = p2->next;
}
/*此時pivot並不在中間，我們要把他放到中間，以他為基準，把資料分為左右兩邊*/
SwapData(&p1->data, &pBegin->data);
//此時p1是中值節點
//if(p1->data >pBegin->data)
QuickSort(pBegin, p1);
//if(p1->data < pEnd->data)
QuickSort(p1->next, pEnd);
}
```
### 3.插入排序
**基本思想**:每一步將一個待排序的記錄，插入到前面已經排好序的有序序列中去，直到插完所有元素為止。
**具體步驟**：
1.將待排序序列第一個元素看做一個有序序列，把第二個元素到最後一個元素當成是未排序序列；
2.取出下一個元素，在已經排序的元素序列中從後向前掃描；
3.如果該元素（已排序）大於新元素，將該元素移到下一位置；
4.重複步驟3，直到找到已排序的元素小於或者等於新元素的位置；
5.將新元素插入到該位置後；
6.重複步驟2~5。
**時間複雜度**：O(N2)
**空間複雜度**：O(1)
**穩定排序**：是
**原地排序**：是
```c
/*不好理解可以除錯下看下具體過程*/
Node *InsertSort(Node *phead)
{
/*為原連結串列剩下用於直接插入排序的節點頭指標*/
Node *unsort;
/*臨時指標變數：插入節點*/
Node *t;
/*臨時指標變數*/
Node *p;
/*臨時指標變數*/
Node *sort;
/*原連結串列剩下用於直接插入排序的節點連結串列：可根據圖12來理解。*/
unsort = phead->next;
/*只含有一個節點的連結串列的有序連結串列：可根據圖11來理解。*/
head->next = NULL;
/*遍歷剩下無序的連結串列*/
while (unsort != NULL)
{
/*注意：這裡for語句就是體現直接插入排序思想的地方*/
/*無序節點在有序連結串列中找插入的位置*/
/*跳出for迴圈的條件：
*1.sort為空，此時，sort->data < t->data，p存下位置，應該放在有序連結串列的後面
*2.sort->data > t->data ，跳出迴圈時，t->data放在有序連結串列sort的前面
*3.sort為空 sort->data > t->data，也插入在sort前面的位置
*/
/*q為有序連結串列*/
for (t = unsort, sort = phead; ((sort != NULL) && (sort->data < t->data)); p = sort, sort = sort->next);
/*退出for迴圈，就是找到了插入的位置插入位置要麼在前面，要麼在後面*/
/*注意：按道理來說，這句話可以放到下面註釋了的那個位置也應該對的，但是就是不能。原因：你若理解了上面的第3條，就知道了。*/
/*無序連結串列中的第一個節點離開，以便它插入到有序連結串列中。*/
unsort = unsort->next;
/*插在第一個節點之前*/
/*sort->data > t->data*/
/*sort為空 sort->data > t->data*/
if (sort == phead)
{
/*整個無序連結串列給phead*/
phead = t;
}
/*p是sort的前驅，這樣說不太確切，當sort到最後時，for裡面有個sort = sort->next，
*就會把sort置空，所以要用p暫存上一次sort的值。而且執行判斷sort->data < t->data時，用的也是上一次的sort
*/
/*sort後面插入*/
/*sort遍歷到了最後，此時，sort->data < t->data,sort和p都為最後一個元素。*/
else
{
p->next = t;
}
/*if處理之後，t為無序連結串列，因為要在phead前插入。這裡先把t賦值給phead，再把t的next指向sort，
*就完成了在sort之前插入小的元素，很巧妙的一種方法
*else處理完之後，sort存放的是sort的下一次，真正的sort存放在p中。不滿足條件跳出迴圈時，判斷的是下一次的sort，
但是我們要用的插入的位置為上一次的sort，所以要記錄下sort上一次的位置
*/
/*完成插入動作*/
/*當sort遍歷完成為空時，t->next就是斷開後面的元素（sort為空）*/
/*當sort不為空時，sort->data > t->data，sort存放的元素比t要大，放在後面，t->next就是再連結起來sort*/
t->next = sort;
/*unsort = unsort->next;*/
}
head = phead;
return phead;
}
```
### 4.選擇排序
**基本思想**：首先，找到陣列中最小的那個元素，其次，將它和陣列的第一個元素交換位置(如果第一個元素就是最小元素那麼它就和自己交換)。其次，在剩下的元素中找到最小的元素，將它與陣列的第二個元素交換位置。如此往復，直到將整個陣列排序。這種方法我們稱之為選擇排序。
**具體步驟**：
1.首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
2.再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。
3.重複第二步，直到所有元素均排序完畢。
**時間複雜度**：O(N2)
**空間複雜度**：O(1)
**穩定排序**：否
**原地排序**：是
```c
Node* SelectSort(Node* phead)
{
Node *temp;
Node *temphead = phead;
/*將第一次的最大值設定為頭結點*/
int max = phead->data;
/*交換變數*/
for(int i = 0;i