本文目錄一覽：
鏈表排序的原理是什麼
==========================
功能：選擇排序(由小到大)
返回：指向鏈表表頭的指針
==========================
*/
/*
選擇排序的基本思想就是反覆從還未排好序的那些節點中，
選出鍵值（就是用它排序的字段，我們取學號num為鍵值）最小的節點，
依次重新組合成一個鏈表。
我認為寫鏈表這類程序，關鍵是理解：
head存儲的是第一個節點的地址，head-next存儲的是第二個節點的地址；
任意一個節點p的地址，只能通過它前一個節點的next來求得。
單向鏈表的選擇排序圖示：
—-[1]—-[3]—-[2]…—-[n]—-[NULL]（原鏈表）
head 1-next 3-next 2-next n-next
—-[NULL]（空鏈表）
first
tail
—-[1]—-[2]—-[3]…—-[n]—-[NULL]（排序後鏈表）
first 1-next 2-next 3-next tail-next
圖10：有N個節點的鏈表選擇排序
1、先在原鏈表中找最小的，找到一個後就把它放到另一個空的鏈表中；
2、空鏈表中安放第一個進來的節點，產生一個有序鏈表,並且讓它在原鏈表中分離出來（此時要注意原鏈表中出來的是第一個節點還是中間其它節點）；
3、繼續在原鏈表中找下一個最小的，找到後把它放入有序鏈表的尾指針的next,然後它變成其尾指針；
*/
struct student *SelectSort(struct student *head)
{
struct student *first; /*排列後有序鏈的表頭指針*/
struct student *tail; /*排列後有序鏈的表尾指針*/
struct student *p_min; /*保留鍵值更小的節點的前驅節點的指針*/
struct student *min; /*存儲最小節點*/
struct student *p; /*當前比較的節點*/
first = NULL;
while (head != NULL) /*在鏈表中找鍵值最小的節點。*/
{
/*注意：這裡for語句就是體現選擇排序思想的地方*/
for (p=head,min=head; p-next!=NULL; p=p-next) /*循環遍歷鏈表中的節點，找出此時最小的節點。*/
{
if (p-next-num min-num) /*找到一個比當前min小的節點。*/
{
p_min = p; /*保存找到節點的前驅節點：顯然p-next的前驅節點是p。*/
min = p-next; /*保存鍵值更小的節點。*/
}
}
/*上面for語句結束後，就要做兩件事；一是把它放入有序鏈表中；二是根據相應的條件判斷，安排它離開原來的鏈表。*/
/*第一件事*/
if (first == NULL) /*如果有序鏈表目前還是一個空鏈表*/
{
first = min; /*第一次找到鍵值最小的節點。*/
tail = min; /*注意：尾指針讓它指向最後的一個節點。*/
}
else /*有序鏈表中已經有節點*/
{
tail-next = min; /*把剛找到的最小節點放到最後，即讓尾指針的next指向它。*/
tail = min; /*尾指針也要指向它。*/
}
/*第二件事*/
if (min == head) /*如果找到的最小節點就是第一個節點*/
{
head = head-next; /*顯然讓head指向原head-next,即第二個節點，就OK*/
}
else /*如果不是第一個節點*/
{
p_min-next = min-next; /*前次最小節點的next指向當前min的next,這樣就讓min離開了原鏈表。*/
}
}
if (first != NULL) /*循環結束得到有序鏈表first*/
{
tail-next = NULL; /*單向鏈表的最後一個節點的next應該指向NULL*/
}
head = first;
return head;
}
/*
==========================
功能：直接插入排序(由小到大)
返回：指向鏈表表頭的指針
==========================
*/
/*
直接插入排序的基本思想就是假設鏈表的前面n-1個節點是已經按鍵值
（就是用它排序的字段，我們取學號num為鍵值）排好序的，對於節點n在
這個序列中找插入位置，使得n插入後新序列仍然有序。按照這種思想，依次
對鏈表從頭到尾執行一遍，就可以使無序鏈表變為有序鏈表。
單向鏈表的直接插入排序圖示：
—-[1]—-[3]—-[2]…—-[n]—-[NULL]（原鏈表）
head 1-next 3-next 2-next n-next
—-[1]—-[NULL]（從原鏈表中取第1個節點作為只有一個節點的有序鏈表）
head
圖11
—-[3]—-[2]…—-[n]—-[NULL]（原鏈表剩下用於直接插入排序的節點）
first 3-next 2-next n-next
圖12
—-[1]—-[2]—-[3]…—-[n]—-[NULL]（排序後鏈表）
head 1-next 2-next 3-next n-next
圖13：有N個節點的鏈表直接插入排序
1、先在原鏈表中以第一個節點為一個有序鏈表，其餘節點為待定節點。
2、從圖12鏈表中取節點，到圖11鏈表中定位插入。
3、上面圖示雖說畫了兩條鏈表，其實只有一條鏈表。在排序中，實質只增加了一個用於指向剩下需要排序節點的頭指針first罷了。
這一點請讀者務必搞清楚，要不然就可能認為它和上面的選擇排序法一樣了。
*/
struct student *InsertSort(struct student *head)
{
struct student *first; /*為原鏈表剩下用於直接插入排序的節點頭指針*/
struct student *t; /*臨時指針變量：插入節點*/
struct student *p; /*臨時指針變量*/
struct student *q; /*臨時指針變量*/
first = head-next; /*原鏈表剩下用於直接插入排序的節點鏈表：可根據圖12來理解。*/
head-next = NULL; /*只含有一個節點的鏈表的有序鏈表：可根據圖11來理解。*/
while (first != NULL) /*遍歷剩下無序的鏈表*/
{
/*注意：這裡for語句就是體現直接插入排序思想的地方*/
for (t=first, q=head; ((q!=NULL) (q-num t-num)); p=q, q=q-next); /*無序節點在有序鏈表中找插入的位置*/
/*退出for循環，就是找到了插入的位置*/
/*注意：按道理來說，這句話可以放到下面注釋了的那個位置也應該對的，但是就是不能。原因：你若理解了上面的第3條，就知道了。*/
first = first-next; /*無序鏈表中的節點離開，以便它插入到有序鏈表中。*/
if (q == head) /*插在第一個節點之前*/
{
head = t;
}
else /*p是q的前驅*/
{
p-next = t;
}
t-next = q; /*完成插入動作*/
/*first = first-next;*/
}
return head;
}
/*
==========================
功能：冒泡排序(由小到大)
返回：指向鏈表表頭的指針
==========================
*/
/*
冒泡排序的基本思想就是對當前還未排好序的範圍內的全部節點，
自上而下對相鄰的兩個節點依次進行比較和調整，讓鍵值（就是用它排
序的字段，我們取學號num為鍵值）較大的節點往下沉，鍵值較小的往
上冒。即：每當兩相鄰的節點比較後發現它們的排序與排序要求相反時，
就將它們互換。
單向鏈表的冒泡排序圖示：
—-[1]—-[3]—-[2]…—-[n]—-[NULL]（原鏈表）
head 1-next 3-next 2-next n-next
—-[1]—-[2]—-[3]…—-[n]—-[NULL]（排序後鏈表）
head 1-next 2-next 3-next n-next
圖14：有N個節點的鏈表冒泡排序
任意兩個相鄰節點p、q位置互換圖示:
假設p1-next指向p，那麼顯然p1-next-next就指向q,
p1-next-next-next就指向q的後繼節點，我們用p2保存
p1-next-next指針。即：p2=p1-next-next，則有：
[ ]—-[p]———-[q]—-[ ]（排序前）
p1-next p1-next-next p2-next
圖15
[ ]—-[q]———-[p]—-[ ]（排序後）
圖16
1、排序後q節點指向p節點，在調整指向之前，我們要保存原p的指向節點地址，即：p2=p1-next-next；
2、順着這一步一步往下推,排序後圖16中p1-next-next要指的是p2-next,所以p1-next-next=p2-next;
3、在圖15中p2-next原是q發出來的指向，排序後圖16中q的指向要變為指向p的，而原來p1-next是指向p的，所以p2-next=p1-next;
4、在圖15中p1-next原是指向p的，排序後圖16中p1-next要指向q,原來p1-next-next（即p2)是指向q的，所以p1-next=p2;
5、至此，我們完成了相鄰兩節點的順序交換。
6、下面的程序描述改進了一點就是記錄了每次最後一次節點下沉的位置，這樣我們不必每次都從頭到尾的掃描，只需要掃描到記錄點為止。
因為後面的都已經是排好序的了。
*/
struct student *BubbleSort(struct student *head)
{
struct student *endpt; /*控制循環比較*/
struct student *p; /*臨時指針變量*/
struct student *p1;
struct student *p2;
p1 = (struct student *)malloc(LEN);
p1-next = head; /*注意理解：我們增加一個節點，放在第一個節點的前面，主要是為了便於比較。因為第一個節點沒有前驅，我們不能交換地址。*/
head = p1; /*讓head指向p1節點，排序完成後，我們再把p1節點釋放掉*/
for (endpt=NULL; endpt!=head; endpt=p) /*結合第6點理解*/
{
for (p=p1=head; p1-next-next!=endpt; p1=p1-next)
{
if (p1-next-num p1-next-next-num) /*如果前面的節點鍵值比後面節點的鍵值大，則交換*/
{
p2 = p1-next-next; /*結合第1點理解*/
p1-next-next = p2-next; /*結合第2點理解*/
p2-next = p1-next; /*結合第3點理解*/
p1-next = p2; /*結合第4點理解*/
p = p1-next-next; /*結合第6點理解*/
}
}
}
p1 = head; /*把p1的信息去掉*/
head = head-next; /*讓head指向排序後的第一個節點*/
free(p1); /*釋放p1*/
p1 = NULL; /*p1置為NULL，保證不產生“野指針”，即地址不確定的指針變量*/
return head;
}
/*
==========================
功能：插入有序鏈表的某個節點的後面(從小到大)
返回：指向鏈表表頭的指針
==========================
*/
/*
有序鏈表插入節點示意圖：
—-[NULL]（空有序鏈表）
head
圖18：空有序鏈表（空有序鏈表好解決，直接讓head指向它就是了。）
以下討論不為空的有序鏈表。
—-[1]—-[2]—-[3]…—-[n]—-[NULL]（有序鏈表）
head 1-next 2-next 3-next n-next
圖18：有N個節點的有序鏈表
插入node節點的位置有兩種情況：一是第一個節點前，二是其它節點前或後。
—-[node]—-[1]—-[2]—-[3]…—-[n]—-[NULL]
head node-next 1-next 2-next 3-next n-next
圖19：node節點插在第一個節點前
—-[1]—-[2]—-[3]…—-[node]…—-[n]—-[NULL]
head 1-next 2-next 3-next node-next n-next
圖20：node節點插在其它節點後
*/
struct student *SortInsert(struct student *head, struct student *node)
{
struct student *p; /*p保存當前需要檢查的節點的地址*/
struct student *t; /*臨時指針變量*/
if (head == NULL) /*處理空的有序鏈表*/
{
head = node;
node-next = NULL;
n += 1; /*插入完畢，節點總數加1*/
return head;
}
p = head; /*有序鏈表不為空*/
while (p-num node-num p != NULL) /*p指向的節點的學號比插入節點的學號小，並且它不等於NULL*/
{
t = p; /*保存當前節點的前驅，以便後面判斷後處理*/
p = p-next; /*後移一個節點*/
}
if (p == head) /*剛好插入第一個節點之前*/
{
node-next = p;
head = node;
}
else /*插入其它節點之後*/
{
t-next = node; /*把node節點加進去*/
node-next = p;
}
n += 1; /*插入完畢，節點總數加1*/
return head;
}
/*
測試代碼如下：
*/
/*測試SelectSort():請編譯時去掉注釋塊*/
/*
head = SelectSort(head);
Print(head);
*/
/*測試InsertSort():請編譯時去掉注釋塊*/
/*
head = InsertSort(head);
Print(head);
*/
/*測試BubbleSort():請編譯時去掉注釋塊*/
/*
head = BubbleSort(head);
Print(head);
*/
/*測試SortInsert():上面創建鏈表，輸入節點時請注意學號num從小到大的順序。請編譯時去掉注釋塊*/
/*
stu = (struct student *)malloc(LEN);
printf(“\nPlease input insert node — num,score: “);
scanf(“%ld,%f”,stu-num,stu-score);
head = SortInsert(head,stu);
free(stu);
stu = NULL;
Print(head);
*/
golang 實現選擇排序算法
選擇排序提高了冒泡排序的性能，它每遍歷一次列表只交換一次數據，即進行一次遍歷時找 到最大的項，完成遍歷後，再把它換到正確的位置。和冒泡排序一樣，第一次遍歷後，最大的數 據項就已歸位，第二次遍歷使次大項歸位。這個過程持續進行，一共需要 n-1 次遍歷來排好 n 個數 據，因為最後一個數據必須在第 n-1 次遍歷之後才能歸位。
golang 冒泡排序
冒泡排序要對一個列表多次重複遍歷。它要比較相鄰的兩項，並且交換順序排錯的項。每對 列表實行一次遍歷，就有一個最大項排在了正確的位置。大體上講，列表的每一個數據項都會在 其相應的位置 “冒泡”。如果列表有 n 項，第一次遍歷就要比較 n-1 對數據。需要注意，一旦列 表中最大(按照規定的原則定義大小)的數據是所比較的數據對中的一個，它就會沿着列表一直 後移，直到這次遍歷結束
雙向循環鏈表怎麼實現排序冒泡排序
#include stdio.h
#include string.h
typedef struct Node
{
int num;
struct Node *pre;
struct Node *next;
}My_Node;
// head為雙向鏈表表頭
// dir為排序方向：0為升序，1為降序
void sort_list(My_Node *head, int dir)
{
if(head == NULL) return ;
My_Node *now_item = head;
My_Node *next_item = NULL;
int tmp = 0;
while(now_item-next != NULL)
{
next_item = now_item-next;
while(next_item != NULL next_item-pre != head (next_item-pre-num next_item-num) ^ dir)
{
tmp = next_item-num;
next_item-num = next_item-pre-num;
next_item-pre-num = tmp;
next_item = next_item-pre;
}
now_item = now_item-next;
}
}
//打印排序後結果
void print_list(My_Node *head)
{
My_Node *p = head-next;
while(p != NULL)
{
printf(“%d “, p-num);
p = p-next;
}
printf(“\n”);
}
//測試數據
void test()
{
int list[10] = {4, 2, 5, 6, 1, 9, 7, 3, 8, 0};
int i;
My_Node *head = (My_Node *)malloc(sizeof(My_Node));
My_Node *p = NULL;
head-pre = head-next = NULL;
for(i=0; i10; i++)
{
p = (My_Node *)malloc(sizeof(My_Node));
p-num = list[i];
p-next = head-next;
if(head-next != NULL) head-next-pre = p;
head-next = p;
p-pre = head;
}
printf(“原序列: “);
print_list(head);
sort_list(head, 0);
printf(“升序排序: “);
print_list(head);
sort_list(head, 1);
printf(“降續排序: “);
print_list(head);
}
int main()
{
test();
return 0;
}
//貼上來格式都沒了。。
C++單向鏈表 冒泡排序
templateclass T
class ChainNode{
friend ChainT;
template class T friend ostream operator(ostream os, const ChainT c);
private:
T data;
ChainNodeT* link;
};
templateclass T
class Chain{
friend ChainIteratorT;
private:
ChainNodeT* first;
bool Bubble(ChainNodeT* current); // 遞歸函數，從鏈表的最後一對數開始冒泡至current
pubilc:
void InsertionSort(); //插入算法對鏈表進行升序排序，不得創建新結點和刪除老結點
void BubbleSort(); // 冒泡排序
void SelectionSort(); // 選擇排序
void RankSort(); // 計數排序
};
template class T
void ChainT::InsertionSort() //插入算法對鏈表進行升序排序，不創建新結點和刪除老結點
{
if (first)
for (ChainNodeT* current = first; current-link;){ // current-link為當前要插入的數據
for (ChainNodeT* p = first; p-data current-link-data; p = p-link); // p指向表中第一個大於或等於當前要插入數據的數據
if (p == current-link){ // 表中沒有比current-link大的數據
current = current-link;
continue; // 繼續下一個數據插入
}
if (p!= current){ // 將要插入的數據挪到第一個比它大的數後面
ChainNodeT* n = current-link-link;
current-link-link = p-link;
p-link = current-link;
current-link = n;
}
else
current = current-link; // 如果已經在第一個比他大的數後面了，更新current-link
T x = p-link-data; //交換要插入元素和他前面那個比它大的元素
p-link-data = p-data;
p-data = x;
}
}
// 問題1：插入排序對於已排好序的鏈表仍需檢驗n(n – 1)次，能否及時終止插入排序？
template class T
bool ChainT::Bubble(ChainNodeT* current) // 遞歸函數，從鏈表的最後一對數開始冒泡至current
{
bool sorted = true; // 如果鏈表已排好序（未發生交換），返回true
if (current current-link current-link-link)
sorted = Bubble(current-link);
if (current-data current-link-data){
T temp = current-data;
current-data = current-link-data;
current-link-data = temp;
sorted = false;
}
return sorted;
}
template class T
void ChainT::BubbleSort() // 冒泡排序
{
bool sorted = false;
for (ChainNodeT* start = first; start start-link !sorted; start = start-link)
sorted = Bubble(start);
}
問題2：不使用遞歸函數能否以同樣的檢索次數排序？
template class T
void ChainT::SelectionSort() // 選擇排序
{
bool sorted = false;
for (ChainNodeT* start = first; start start-link !sorted; start = start-link){
sorted = true;
for (ChainNodeT* current = start-link; current; current = current-link){
if (current-data start-data){ // 交換
T temp = current-data;
current-data = start-data;
start-data = temp;
}
if (sorted current-link current-data current-link-data) // 如果在鏈表中存在比後一項大的項，則表示未排序
sorted = false;
}
}
}
【golang】冒泡排序和選擇排序
運行結果：
flag的作用：排序不一定會走完所有循環，有可能在中間就完成了排序。只要發現在某一輪的循環中，沒有發生任何交換，就說明每一組都是前面的數比下一個數小，如此就不用再往下進行，終止循環。
運行結果：
原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-hant/n/194717.html
微信掃一掃 
支付寶掃一掃 