㈠ 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就是最常用的状态码），主调函数可以通过返回值判断被调函数的执行情况。