常用連結串列排序演算法
==========================
功能:選擇排序(由小到大)
返回:指向連結串列表頭的指標
==========================
*/
/*
選擇排序的基本思想就是反覆從還未排好序的那些節點中,
選出鍵值(就是用它排序的欄位,我們取學號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);
*/