㈠ C語言的鏈表怎麼排序
==========================
功能：選擇排序(由小到大)
返回：指向鏈表表頭的指針
==========================
*/
/*
選擇排序的基本思想就是反復從還未排好序的那些節點中，
選出鍵值（就是用它排序的欄位，我們取學號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);
*/
本文來自CSDN博客，轉載請標明出處：http://blog.csdn.net/northplayboy/archive/2005/12/14/552388.aspx
㈡ C++單向鏈表 冒泡排序
template<class T>
class ChainNode{
friend Chain<T>;
template <class T> friend ostream& operator<<(ostream& os, const Chain<T>& c);
private:
T data;
ChainNode<T>* link;
};
template<class T>
class Chain{
friend ChainIterator<T>;
private:
ChainNode<T>* first;
bool Bubble(ChainNode<T>* current); // 遞歸函數，從鏈表的最後一對數開始冒泡至current
pubilc:
void InsertionSort(); //插入演算法對鏈表進行升序排序，不得創建新結點和刪除老結點
void BubbleSort(); // 冒泡排序
void SelectionSort(); // 選擇排序
void RankSort(); // 計數排序
};
template <class T>
void Chain<T>::InsertionSort() //插入演算法對鏈表進行升序排序，不創建新結點和刪除老結點
{
if (first)
for (ChainNode<T>* current = first; current->link;){ // current->link為當前要插入的數據
for (ChainNode<T>* p = first; p->data < current->link->data; p = p->link); // p指向表中第一散改個大於或等於當前要插入數據的數據
if (p == current->link){ // 表中沒有比current->link大的數據
current = current->link;
continue; // 繼續下一個數據插入褲枯
}
if (p!= current){ // 將要插入的數據挪到第沖純判一個比它大的數後面
ChainNode<T>* 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 Chain<T>::Bubble(ChainNode<T>* 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 Chain<T>::BubbleSort() // 冒泡排序
{
bool sorted = false;
for (ChainNode<T>* start = first; start && start->link && !sorted; start = start->link)
sorted = Bubble(start);
}
問題2：不使用遞歸函數能否以同樣的檢索次數排序？
template <class T>
void Chain<T>::SelectionSort() // 選擇排序
{
bool sorted = false;
for (ChainNode<T>* start = first; start && start->link && !sorted; start = start->link){
sorted = true;
for (ChainNode<T>* 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 &¤t->data > current->link->data) // 如果在鏈表中存在比後一項大的項，則表示未排序
sorted = false;
}
}
}
㈢ 雙向循環鏈表怎麼實現排序冒泡排序
#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; i<10; 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語言鏈表如何實現冒泡排序
將鏈表地址存入一個數組，在內循搜盯環的比較階段，取出數組地址對應的內容進行比較和排序，這樣就可以實現鏈表冒泡排序了。。
這里假設你已經知道怎麼進行冒泡排序編程了，所以僅作文字世裂和說明，不再源差寫例子程序了。。
㈤ 一單鏈表中元素無序，編寫演算法將之排成有序序列
由冒泡排序得到啟示，每趟均從頭節點開始掃描，比較相鄰兩節點的數據，
滿足特定要求時進行節點交換。
需要注意的是，必須有一個指針保存當前節點的前一個位置，這樣在交換
節點後鏈表不會斷開；並且要指定一個哨兵節點作為每趟比較的終結點，該哨
兵節點實際上就是有序區的首節點。
structNode{
intdata;
Node*next;
};
/*因為排序後頭結點指橋跡針可能發生改變，所以參數是二級指針*/
voidlistSort(Node**head)
{
if(head==NULL||*head==NULL)
return;
Node*cur,*post,*pre,*sentinel=NULL;//sentinel標記有序區的首個節點
boolsorted;
do{
pre=NULL;
cur=*head;
sorted=true;
/*反復用當前節點cur與下一個節點post進行比較*/
while((post=cur->next)!=sentinel){
if(cur->data>post->data){
sorted=false;//發生交換，則仍未有序
cur->next=post->next;
post->next=cur;
亂鋒
if(pre!=NULL)
pre->next=post;
pre=post;
if(cur==*head)
*head=post;//保證頭指針指向最小的節點
}else{
pre=cur;
cur=post;
敏陪並}
}
sentinel=cur;//cur為該趟排好序的節點
}while(!sorted);//若未發生交換，則已經有序
}
㈥ 急！！求c語言單鏈表冒泡排序的詳細流程圖
#include<stdio.h> #include<malloc.h> struct number { int num; struct number *next; }; void main() { struct number *head; struct number *p1,*p2,*p,*p3,*p4; int n=0,m,i,j; p1=p2=(struct number *)malloc(sizeof(struct number)); printf("\nWang jianfei 060806110006\n\n\n"); printf("Please enter the number: \n"); scanf("%d",&p1->num); head=NULL; while(p1->num!=NULL) { n=n+1; if(head==NULL) head=p1; else p2->next=p1; p2=p1; p1=(struct number *)malloc(sizeof(struct number)); scanf("%d",&p1->num); } p2->next=NULL; p=head; for(p4=head;p4!=NULL;p4=p4->next) { for(p3=head;p3->next!=NULL;p3=p3->next) { if(p4->num>p3->num) { m=p4->num; p4->num=p3->num; p3->num=m; } } p=head; } printf("\nNow,there %d numbers are: ",n); p=head; printf("\n"); if(head!=NULL) do { printf("%5d ",p->num); p=p->next; }while(p!=NULL); printf("\n"); getch(); }
㈦ 鏈式存儲序列能用冒泡排序嗎
可以啊，冒泡排序就是和鄰居逆序時交換記錄或者關鍵字，皮搏枯燃洞在單鏈表上可以完成下銀笑沉的冒泡排序，雙鏈表則還可以完成上浮的冒泡排序
㈧ C語言鏈表如何實現冒泡排序
兩種 思路：
1、交換鏈表中各節點的數據，不交散鍵換節點；
2、交換節點，即節點沖臘巧link指針的內容。
下面以第一種思路為例：
void sort(LinkList *L)
{
int i,j,t;
LinkList *p = L;
int count = 0;
while(p->link != NULL)
{
count++;
p = p->link;
}
for(i=0;i<count-1;i++) /* 冒泡法排序 */
{
p = L;
for(j=0;j<count-i-1;j++)
{
if(p->data > p->link->data)
{
t=p->局配data;
p->data = p->link->data;
p->link->data=t;
}
p = p->link;
}
}
}
㈨ 求C語言高手指導 用鏈表怎樣排序（鏈表中有一個p->score變數作為比較大小排序的標准）
#include<stdio.h>
#include<malloc.h>
#include<string.h>舉岩
struct node
{
char data[20] ;
struct node*link ;
};
typedef struct node ListNode ;
void ListInsert(ListNode**L,char x[]) //構造鏈表時直接排序
{
ListNode *p, *q, *curr ;
p = (ListNode*)malloc(sizeof(ListNode));
//構造一個新結點
strcpy(p->data,x);
p->link = NULL;
//原鏈表沒有結點的情況
if((*L) == NULL)
{
(*L) = p;
return;
}
else if(strcmp(x,(*L)->data) <= 0)
{
p->link = (*L);
(*L) = p;
return;
}
else
{
curr = (*L);
q = (*L);
/銷簡/找到比x大的第一個元素
while(q != NULL && strcmp(x,q->data) >= 0)
{
curr = q;
q = q->link;
}
p->link = curr->link;
curr->link = p;
return;
}
}
void Print(ListNode*L) //輸出函虧答褲數
{
ListNode *curr = L;
while(curr!=NULL)
{
printf("%s ",curr->data);
curr=curr->link ;
}
}
void main()
{
int n,i ;
char a[20];
ListNode *head ;
head=NULL ;
printf("請你輸入要輸入的元素的個數: ");
scanf("%d",&n);
printf("請你逐個輸入%d個字元型元素:\n",n);
for(i = 0;i < n;i++)
{
scanf("%s",a);
ListInsert(&head,a);
}
printf("鏈表中數據輸出如下：\n");
Print(head);
}
㈩ C語言做鏈表的排序
＃include＂stdafx．h＂
＃include＜stdlib．h＞
／／創建一個節點，data為value，指向NULL
Node＊Create（intvalue）｛
Node＊head＝（Node＊）malloc（sizeof（Node））；
head－＞data＝value；
head－＞next＝NULL；
returnhead；
｝
／／銷毀鏈表
boolDestroy＿List（Node＊head）｛
Node＊temp；
while（head）｛
temp＝head－＞next；
free（head）；
head＝temp；
｝
head＝NULL；
returntrue；
｝
／／表後添加一個節點，Create（value）
boolAppend（Node＊head，intvalue）｛
Node＊n＝Create（value）；
Node＊temp＝head；
while（temp－＞next）｛
temp＝temp－＞next；
｝
temp－＞next＝n；
return0；
｝
／／列印鏈表
voidPrint＿List（Node＊head）｛
Node＊temp＝head－＞next；
while（temp）｛
printf（＂％d－＞＂，temp－＞data）；
temp＝temp－＞next；
｝
printf（＂＼n＂）；
｝
／／在鏈表的第locate個節點後（頭節點為0）插入創建的節點Create（value）
boolInsert＿List（Node＊head，intlocate，intvalue）｛
Node＊temp＝head；
Node＊p；
Node＊n＝Create（value）；
if（locate＜0）
returnfalse；
while（locate－－）｛
if（temp－＞next＝＝NULL）｛
temp－＞next＝Create（value）；
returntrue；
｝
temp＝temp－＞next；
｝
p＝temp－＞next；
temp－＞next＝n；
n－＞next＝p；
returntrue；
｝
／／刪除第locate個節點後（頭節點為0）的節點
boolDelete＿List（Node＊head，intlocate）｛
Node＊temp＝head；
Node＊p；
if（locate＜0）
returnfalse；
while（locate－－）｛
if（temp＝＝NULL）｛
returnfalse；
｝
temp＝temp－＞next；
｝
p＝temp－＞next－＞next；
free（temp－＞next）；
temp－＞next＝NULL；
temp－＞next＝p；
returntrue；
｝
／／獲取鏈表長度（不包括頭節點）
intSize＿List（Node＊head）｛
Node＊temp＝head；
intsize＝0；
while（temp－＞next）｛
temp＝temp－＞next；
size＋＋；
｝
returnsize；
｝
／／鏈表的三種排序（選擇，插入，冒泡）
boolSort＿List（Node＊head）｛
intt＝0；
intsize＝Size＿List（head）；
／／選擇排序
／＊for（Node＊temp＝head－＞next；temp！＝NULL；temp＝temp－＞next）｛
for（Node＊p＝temp；p！＝NULL；p＝p－＞next）｛
if（temp－＞data＞p－＞data）｛
printf（＂換％d和％d＼n＂，temp－＞data，p－＞data）；
t＝temp－＞data；
temp－＞data＝p－＞data；
p－＞data＝t；
｝
｝
｝＊／
／／插入排序
／＊for（Node＊temp＝head－＞next－＞next；temp！＝NULL；temp＝temp－＞next）｛
for（Node＊p＝head；p－＞next！＝NULL；p＝p－＞next）｛
if（p－＞next－＞data＞temp－＞data）
｛
printf（＂換％d和％d＼n＂，temp－＞data，p－＞next－＞data）；
t＝temp－＞data；
temp－＞data＝p－＞next－＞data；
p－＞next－＞data＝t；
｝
｝
｝＊／
／／冒泡排序
for（Node＊temp＝head－＞next；temp－＞next！＝NULL；temp＝temp－＞next）｛
for（Node＊p＝head－＞next；p－＞next！＝NULL；p＝p－＞next）｛
if（p－＞data＞p－＞next－＞data）｛
t＝p－＞data；
p－＞data＝p－＞next－＞data；
p－＞next－＞data＝t；
｝
｝
｝
return0；
｝
(10)鏈表冒泡排序演算法擴展閱讀：
return表示把程序流程從被調函數轉向主調函數並把表達式的值帶回主調函數，實現函數值的返回，返回時可附帶一個返回值，由return後面的參數指定。
return通常是必要的，因為函數調用的時候計算結果通常是通過返回值帶出的。如果函數執行不需要返回計算結果，也經常需要返回一個狀態碼來表示函數執行的順利與否（-1和0就是最常用的狀態碼），主調函數可以通過返回值判斷被調函數的執行情況。