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；

｝

扩展资料：

return表示把程序流程从被调函数转向主调函数并把表达式的值带回主调函数，实现函数值的返回，返回时可附带一个返回值，由return后面的参数指定。

return通常是必要的，因为函数调用的时候计算结果通常是通过返回值带出的。如果函数执行不需要返回计算结果，也经常需要返回一个状态码来表示函数执行的顺利与否（-1和0就是最常用的状态码），主调函数可以通过返回值判断被调函数的执行情况。

可以把链表设计成循环链表，用冒泡排序

在排序前设计一个交换标记，如在循环过程中有交换，则修改这个标记变量，如果在一次循环（当前节点为刚开始时节点，表示循环了一次）中，交换标记没有被修改，则表明该数列已排好序。

现在给一个双向循环链表的排序程序给你，该程序用了双向冒泡排序（也就是鸡尾酒排序法），希望对你有帮助

双向链表我用的鸡尾酒排序,也就是双向冒泡排序

#include<stdio.h>

#define LEN sizeof(struct list)

struct list//双向链表有两个指针域，一个指向前节点，一个指向后继节点

{struct list *lp //lp为前节点指针，rp为后继节点指针

int x

struct list *rp

}

int n

struct list *creat(void)

{struct list *head

struct list *p1,*p2 //两个节点指针，腊顷p1是当前新建节点指针，p2为p1的前一个节点

n=0

p1=p2=(struct list*)malloc(LEN)//申请内存空间

scanf("%d"顷并,&p1->x)

head=NULL //先把头指针设置为空

while(p1->x!=0)

{n=n+1

if(n==1){p1->lp=NULLhead=p1} //把head指向轮乎陆链表的第一个节点并把首节点的lp设为NULL

else

{p1->lp=p2新建了一个节点，把它的lp指向前一个节点p2

p2->rp=p1}把前节点的rp指针指向刚建立的节点

p2=p1 进行迭代，p1变成下一个新节点的后继节点

p1=(struct list*)malloc(LEN)//每次新建节点都要向系统申请内存空间

scanf("%d",&p1->x)

}

p2->rp=NULL 把随后的节点后继指针设为空

return(head)

}

void print(struct list *head)

{struct list *p

printf("\nNow,Thess %d records are :\n",n)

p=head

if(head!=NULL)

do

{printf("%d ",p->x)

p=p->rp//这个是个迭代过程，把p的后继节点变成下一次要输出的节点

}while(p!=NULL)

}

void sort(struct list *head) //排序用的双向排序法，提高排序效率

{struct list *p,*bottom,*top

int f,temp

p=head

if(head!=NULL)

{ f=1

bottom=NULL //bottom和top为数列左右冒泡的边界节点

top=NULL

while(f==1) //f为交换标记，如果没交换则f没变就推出循环

{f=0

do

{

if(p->x >(p->rp)->x)

{temp=p->x

p->x=(p->rp)->x

(p->rp)->x=temp

f=1

}

p=p->rp

}while(p->rp!=top)

print(head)

top=p

if((f==0)||(top==bottom))break

f=0

do

{

if(p->x<(p->lp)->x)

{

temp=p->x

p->x=(p->lp)->x

(p->lp)->x=temp

f=1

}

p=p->lp

}while(p->lp!=bottom)

bottom=p

if(top==bottom)break

print(head)

}

}

}

void main() //所有的函数都做成全局函数，可以随时调用

{struct list *head

head=creat() //建立链表

print(head) //输出链表

sort(head) //排序

print(head) //输出链表

system("PAUSE")

}

#include <stdio.h>

#include <stdlib.h>

//申明链表

typedef struct node

{

char num

struct node *next

}list

void Bubble_sort(list *L)//链表的旦桐冒泡排序

void Dis_list(list *L)//遍历单链表

int main()

{

//建表

list *r,*s,*p

int n=26//存储数据的个数

s=NULL

for(int i='Z'i>='A'i--)

{

r=(list *)malloc(sizeof(list))

r->num = i

if(!s){s=rp=s}

p->next=r

p=r

}

p->next=NULL

printf("排序前:\t")

Dis_list(s)

//排序

Bubble_sort(s)

printf("排序后:\t")

Dis_list(s)

return 0

}

void Dis_list(list *L)

{

list *r

r=L

while(r!=NULL)

{

printf("%c\t"隐举,r->num)

r=r->next

}

printf("\n")

}

void Bubble_sort(list *L)

{

list *r,*s

char temp

for(r=Lrr=r->next)

{

for(s=rss=s->next)

{

if(r->num>s->num)

{

temp=r->num

r->灶迟碧num=s->num

s->num=temp

}

}

}

}

---