c语言写排序函数用链表,c语言顺序表和链表

C语言链表如何排序

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

成都创新互联公司从2013年成立，是专业互联网技术服务公司，拥有项目成都网站制作、成都网站建设网站策划，项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命，1280元长洲做网站,已为上家服务,为长洲各地企业和个人服务,联系电话:028-86922220

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

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

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

#includestdio.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=NULL; head=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");

}

C语言如何对链表的数进行排序？

同学，给你一段代码，里面涵盖了链表的冒泡排序！

#includestdio.h

#includemalloc.h

typedef

struct

node

{

int

data;/*data代表成绩分数*/

struct

node

*next;

}LNode,*LinkList;

LinkList

Creat(void)/*创建链表，结束标志为当输入的数据为0!*/

{

LinkList

H,p1,p2;

int

n;

n=0;

p1=p2=(LinkList)malloc(sizeof(LNode));

printf("输入数据：");

scanf("%d",p1-data);

H=NULL;

while(p1-data!=0)

{

n=n+1;

if(n==1)

H=p1;

else

p2-next=p1;

p2=p1;

p1=(LinkList)malloc(sizeof(LNode));

scanf("%d",p1-data);

}

p2-next=NULL;

return(H);

}

LinkList

Sort(LinkList

SL)/*递增排序函数：入口参数：链表的头指针，此为链表中的排序函数*/

{

LinkList

p,q;

int

temp;

for(p=SL;p!=NULL;p=p-next)

{

for(q=p-next;q!=NULL;q=q-next)

{

if(p-dataq-data)

{

temp=q-data;

q-data=p-data;

p-data=temp;

}

}

}

return

SL;

}

int

main()

{

LinkList

L,S,K;

L=Creat();

printf("初始化的单链表数据序列为:\n");

for(S=L;S!=NULL;S=S-next)

printf("%d

",S-data);

Sort(L);

printf("\n按递增顺序排序后的序列为:\n");

for(K=L;K!=NULL;K=K-next)

printf("%d==",K-data);

return

0;

}

C语言的问题，只允许使用链表，排序函数应该怎么写，求个大致的思路就行

链表也可以用冒泡排序之类的

void sortList (struct lNode * L) {

struct lNode * p,q; //链表结点指针

int temp; //链表结点数据域假设是int型

for (p=L-next; p!=NULL; p=p-next) //冒泡排序

for (q=p-next; q!=NULL; q=q-next)

if (p-data  q-data) {

temp = q-data;

q-data = p-data;

p-data = temp;

}

}

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

C语言 单向链表如何排序？

void link_order(STU *p_head)

{

STU *pb, *pf, temp;

pf = p_head;

if(p_head == NULL) {//链表为空

printf("needn't order.\n");

return ;

}

if(p_head-next == NULL) {//链表有1个节点

printf("only one print, needn't order.\n");

return ;

}

while(pf-next != NULL) {//以pf指向的节点为基准节点

pb = pf-next;//pb从基准点的下一个节点开始

while(pb != NULL) {

if(pf-num pb-num) {

temp = *pf;

*pf = *pb;

*pb = temp;

temp.next = pf-next;

pf-next = pb-next;

pb-next = temp.next;

}

pb = pb-next;

}

pf = pf-next;

}

return ;

}

扩展资料：

链表的排序有三种情况：

1、链表为空时：不用排序；

2、链表中有一个节点：不用排序；

3、链表中两个及其以上节点时：排序。

return 0代表程序正常退出。return是C++预定义的语句，它提供了终止函数执行的一种方式。当return语句提供了一个值时，这个值就成为函数的返回值。

return语句用来结束循环，或返回一个函数的值。

1、return 0，说明程序正常退出，返回到主程序继续往下执行。

2、return 1，说明程序异常退出，返回主调函数来处理，继续往下执行。return 0或return 1对程序执行的顺序没有影响，只是大家习惯于使用return(0)退出子程序而已。