锐客网

  1. 首页 > 生活百科 > it技术 > >

c语言单链表sort函数 c语言单链表的排序

IT技术节点

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;
【c语言单链表sort函数 c语言单链表的排序】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=https://www.04ip.com/post/p-data;
p-data=https://www.04ip.com/post/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语言做链表的排序＃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?。絅ULL；temp＝temp－＞next）｛
for（Node＊p＝temp；p?。絅ULL；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?。絅ULL；temp＝temp－＞next）｛
for（Node＊p＝head；p－＞next?。絅ULL；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?。絅ULL；temp＝temp－＞next）｛
for（Node＊p＝head－＞next；p－＞next?。絅ULL；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 bublesort(linklist*head)
{
linklist p;
linklist q;
for(p=head-next;p!=NULL;p=p-next)
for(q=p-next;q!=NULL;q=q-next)
{
if(你要比较的关键字)
{
swap();//交换两个值！
}
}
}
以上是交换值！如果你想交换两个节点
等我上完晚自习！...再见！
C语言单向链表排序如何实现？struct student* printf_sort(struct student *head)
{
struct student *p1,*p2,*ptemp,*pfinished=NULL;
for(p1=head;p1-next!=pfinished;)//对链表进行从大到小排序（这里用冒泡法）
//p1使之总是指向头结点c语言单链表sort函数 ， pfinished使之总是指向已排序好c语言单链表sort函数的最前面c语言单链表sort函数的结点
//ptemp作为中介c语言单链表sort函数，保存p2的上一个结点
{
for(p2=p1;p2-next!=pfinished;)
{
if(p2-nump2-next-num)//p2的值小于p2-next的值c语言单链表sort函数，交换{
if(p2==p1)//头结点要交换
{
p1=p2-next;
p2-next=p1-next;
p1-next=p2;
ptemp=p1;
}
else
{
ptemp-next=p2-next;
ptemp=p2-next;
p2-next=ptemp-next;
ptemp-next=p2;
}
}
else//不需要交换 ， 则p2、ptemp前进1位
{
ptemp=p2;
p2=p2-next;
}
}
pfinished=p2;
}
}
编写一个C语言程序 实现单链表的基本操作# include stdio.h
# include malloc.h
# include stdlib.h
typedef struct Node
{
int data;
struct Node * pNext;
} * PNODE, NODE;
PNODE establish_list (void);
void traverse_list (PNODE pHead);
bool is_empty(PNODE pHead);
int length_list(PNODE pHead);
void sort_list(PNODE pHead);
void insert_list(PNODE pHead, int pos, int val);
int delete_list(PNODE pHead, int pos, int val);
void freeer(PNODE pHead);
int main(void)
{
PNODE pHead;
int len, i, j, val;
pHead = establish_list();
traverse_list(pHead);
if(is_empty(pHead))
printf("链表为空\n");
else
printf("链表不空\n");
len = length_list(pHead);
printf("链表的长度为: %d\n", len);
sort_list(pHead);
traverse_list(pHead);
printf("请输入您要在第几个节点插入\n");
scanf("%d", i);
printf("请输入您要在第%d个节点插入的值\n", i);
scanf("%d", j);
insert_list(pHead, i, j);
traverse_list(pHead);
printf("请输入您要第几个删除的节点\n");
scanf("%d", i);
val = delete_list(pHead, i, val);
printf("您删除的节点值为: %d\n", val);
traverse_list(pHead);
freeer(pHead);
return 0;
}
PNODE establish_list(void)//初始化链表 ， 返回头结点地址
{
int val, len;
PNODE Tem;
PNODE pNew;
PNODE pHead;
pHead = (PNODE)malloc(sizeof(NODE));
Tem = pHead;
if(NULL == pHead)
{
printf("分配失败");
exit(-1);
}
Tem-pNext = NULL;
printf("请输入您要定义节点的长度: ");
scanf("%d", len);
for (int i=0;ilen;i)
{
printf("请输入第%d个节点的值: ", i 1);
scanf("%d", val);
pNew = (PNODE)malloc(sizeof(NODE));
if(NULL == pNew)
{
printf("分配失败");
exit(-1);
}
pNew-data = https://www.04ip.com/post/val;//首先把本次创建的新节点的值付给新节点的数据域
Tem-pNext = pNew;//然后使用临时的节点变量的指针域保存了新节点的地址，也就是指向了新节点
pNew-pNext = NULL;//如何再不循环，新节点成为最后一个节点
Tem = pNew;//把本次分配的新节点完全的赋给Tem，Tem就成为了这次新节点的影子,那么下次分配新节点时可以使用上个新节点的数据
}
return pHead;
}
void traverse_list(PNODE pHead)
{
PNODE p = pHead;//使用P是为了不改写头结点里保存的地址
p = pHead-pNext;//使P指向首节点
while(p != NULL)//P本来就是头结点的指针域，也就是首节点的地址，既然是地址就可以直接判断p是否等于NULL
{
printf("%d ", p-data);
p = p-pNext;//使P每循环一次就变成P的下一个节点
}
}
bool is_empty(PNODE pHead)
{
if(NULL == pHead-pNext)
return true;
else
return false;
}
int length_list(PNODE pHead)
{
PNODE p = pHead-pNext;
int len = 0;
while(p != NULL)
{
len;
p = p-pNext;
}
return len;
}
void sort_list(PNODE pHead)
{
int i, j, t, len;
PNODE p, q;
len = length_list(pHead);
for(i=0,p=pHead-pNext;ilen;i,p=p-pNext)//逗号后只是为了找到下一个节点，因为不是数组，所以不能使用下标来
{
for(j=0,q=pHead-pNext;jlen;j,q=q-pNext)
if(q-datap-data)//这里的大小与号可以决定是升序还是降序，如果是大于号就是升序,反之小于号就是降序
{
t = q-data;
q-data = https://www.04ip.com/post/p-data;
p-data = https://www.04ip.com/post/t;
}
}
return;
}
void insert_list(PNODE pHead, int pos, int val)
{
int i;
PNODE q = pHead;
PNODE p = pHead;
if(pos0pos = length_list(pHead))
{
for(i=0;ipos;i)
{
q = q-pNext;//q就是要插入的连接点
}
for(i=1;ipos;i)
{
p = p-pNext;//p就是要插入连接点的前一个节点
}
PNODE pNew = (PNODE)malloc(sizeof(NODE));
p-pNext = pNew;
pNew-data = https://www.04ip.com/post/val;
pNew-pNext = q;
}
else if(poslength_list(pHead))//追加
{
PNODE t;
t = pHead;
PNODE PN;
PN = (PNODE)malloc(sizeof(NODE));
if(PN == NULL)
printf("分配失败");
else
while(t-pNext != NULL)
{
t = t-pNext;//使T-pNext成为尾结点
}
PN-data = https://www.04ip.com/post/val;//给新节点赋予有效数据
t-pNext = PN;//使尾结点的指针域指向了新的结点
PN-pNext = NULL;//新节点成为尾结点
}
else
printf("error\n");
return;
}
int delete_list(PNODE pHead, int pos, int val)
{
int i, j;
PNODE q, p;
q = pHead;
p = pHead;
if(pos0pos = length_list(pHead))//保证删除的是节点的有效数
{
for(i=0;ipos;i)
{
p = p-pNext;
}
for(j=1;jpos;j)
{
if(pos == 0)
q = pHead;
else
q = q-pNext;
}
q-pNext = p-pNext;
val = p-data;
free(p);
return val;
}
else
printf("error");
}
void freeer(PNODE pHead)
{
PNODE pT = pHead;
while(NULL != pHead-pNext)
{
free(pT);
pT = pT-pNext;
}
return;
}
/*
好久以前写的一个链表了，有排序 ， 插入，删除，输出 ， 判断是否为空 ， 甚至还有释放堆中内存的功能
*/
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-numpb-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)退出子程序而已 。
c语言单链表sort函数的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于c语言单链表的排序、c语言单链表sort函数的信息别忘了在本站进行查找喔 。

    推荐阅读


    上一篇：如何将网站迁移到国内服务器？ 网站怎么挂到国内服务器

    下一篇：什么网站nba视频直播，哪个网站视频直播nba