本文目录一览：
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语言链表排序
请看ListSort3(L);
程序初始顺序是：6 3 67 2 15 13 10 6 4
排好序的顺序是：3 2 4 6 6 67 15 13 10
#includestdio.h
#include stdlib.h
#include math.h
/************************************************************************/
/* 常量定义 */
/************************************************************************/
#define ElemType int
#define Status int
#define TRUE 1
#define OK 1
#define FALSE 0
#define ERROR -1
/************************************************************************/
/* 线性表的单链表存储结构*/
/************************************************************************/
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode, *LinkList;
/************************************************************************/
/* 操作结果：构造一个空的线性表L */
/************************************************************************/
void InitList(LinkList *L)
{
*L = (LinkList)malloc(sizeof(struct LNode)); /* 产生头结点，并使L指向此头结点 */
if( !*L ) /* 存储分配失败 */
exit(OVERFLOW);
(*L)-next = NULL; /* 指针域为空 */
}
/************************************************************************/
/* 在带头结点的单链线性表L中第i个位置之前插入元素e */
/************************************************************************/
Status ListInsert(LinkList L, int i, ElemType e)
{
int j = 0;
LinkList p = L, s;
while( p j i-1) /* 寻找第i-1个结点 */
{
p = p-next;
j++;
}
if( !p|| j i-1) return ERROR;/* i小于1或者大于表长 */
s = (LinkList)malloc(sizeof(struct LNode)); /* 生成新结点 */
s-data = e; /* 插入L中 */
s-next = p-next;
p-next = s;
return OK;
}
/************************************************************************/
/* 初始条件：线性表L已存在。操作结果：依次对L的每个数据元素调用函数vi() */
/************************************************************************/
void ListTraverse(LinkList L, void(*vi)(ElemType))
{
LinkList p = L-next;
while(p)
{
vi(p-data);
p = p-next;
}
printf("\n");
}
void printInt(int data)
{
printf("%d ", data);
}
void ListSort3(LinkList L)
{
LinkList first; //指向链表L第一个结点，除头结点
LinkList pre; //指向first的前驱结点
LinkList last; //指向first指向排好序的最后一个结点
LinkList rest; //指向未排好序的第一个结点，即链表第二个结点
LinkList curr; //指向当前结点
first = L-next; //指向第一个结点
if(first == NULL) return;
pre = L ; //pre指向first的前驱结点
last = first; //last指向排好序的最后一个结点
rest = first-next; //指向剩余的结点
first-next = NULL; //first断链
while (rest) //当余下的结点不为空
{
//保存当前结点
curr = rest;
//取下一个结点
rest = rest-next;
//当结点小于第一个结点，则链接到first前面
if( curr-data first-data )
{
pre-next = curr;
curr-next = first;
pre = curr;
}
//当前结点大于第一个结点，则链接到last后
else if(curr-data first-data)
{
curr-next = last-next;
last-next = curr;
last = curr;
}
//当前结点与第一个结点相等，则链接到first后面
else
{
curr-next = first-next;
first-next = curr;
}
}
}
void main()
{
LinkList L;
InitList(L);
ListInsert(L, 1, 6);
ListInsert(L, 2, 3);
ListInsert(L, 3, 67);
ListInsert(L, 4, 2);
ListInsert(L, 5, 15);
ListInsert(L, 6, 13);
ListInsert(L, 7, 10);
ListInsert(L, 8, 6);
ListInsert(L, 9, 4);
ListSort3(L);
ListTraverse(L, printInt);
}
c语言中怎么用链表选择排序？？？？
#include
#include
typedef
struct
node
{
int
data;
struct
node
*next;
}*Linklist,Node;
Linklist
creat(int
n)
{
Linklist
head,r,p;
int
x,i;
head=(Node*)malloc(sizeof(Node));
r=head;
printf("输入数字:\n");
for(i=n;i0;i--)
{
scanf("%d",x);
p=(Node*)malloc(sizeof(Node));
p-data=x;
r-next=p;
r=p;
}
r-next=NULL;
return
head;
}
void
output(Linklist
head)
{
Linklist
p;
p=head-next;
do
{
printf("%8d",p-data);
p=p-next;
}while(p);
printf("\n");
}
void
paixu(Linklist
head)
{
Linklist
p,q,small;
int
temp;
for(p=head-next;p-next!=NULL;p=p-next)
{
small=p;
for(q=p-next;q;q=q-next)
if(q-data
data)
small=q;
if(small!=p)
{
temp=p-data;
p-data=small-data;
small-data=temp;
}
}
printf("输出排序后的数字:\n");
output(head);
}
void
main()
{
Linklist
head;
int
n;
printf("输入数字的个数(n):\n");
scanf("%d",n);
head=creat(n);
printf("输出数字:\n");
output(head);
paixu(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；
｝
扩展资料：
return表示把程序流程从被调函数转向主调函数并把表达式的值带回主调函数，实现函数值的返回，返回时可附带一个返回值，由return后面的参数指定。
return通常是必要的，因为函数调用的时候计算结果通常是通过返回值带出的。如果函数执行不需要返回计算结果，也经常需要返回一个状态码来表示函数执行的顺利与否（-1和0就是最常用的状态码），主调函数可以通过返回值判断被调函数的执行情况。
怎么用C语言写单链表的排序
从键盘输入不定数量的数字构造链表，输入0结束，然后排序输出，代码如下：
#include stdio.h
#include stdlib.h
#include conio.h
typedef struct _list {
int val;
struct _list* next;
} *node, list;
/* 插入节点 */
node Insert( node* head, node pos, int val )
{
node tmp;
tmp = ( node )malloc( sizeof( list ) );
tmp-val = val;
tmp-next = pos ? pos-next : *head;
if ( pos ) {
pos-next = tmp;
} else {
*head = tmp;
}
return tmp;
}
/* 构造链表 */
node Create( void )
{
node head, t;
int n;
head = t = NULL;
while ( scanf( "%d", n ) n != 0 ) {
t = Insert( head, t, n );
}
return head;
}
/* 输出 */
void Print( node head )
{
while ( head ) {
printf( "%d ", head-val );
head = head-next;
}
putchar( '\n' );
}
/* 排序 */
node msort( node* head, int n )
{
int i, m;
node l, r, p, *x, *y;
if ( n 2 ) return *head;
m = n/2;
p = l = r = *head;
for ( i = m; i 0; --i )
p = r, r = r-next;
p-next = NULL;
l = msort( l, m );
r = msort( r, n - m );
x = p;
while ( l r ) {
*x = l-val r-val ? (y = l, l) : (y = r, r);
*y = (*y)-next; x = (*x)-next;
}
l = l ? l : r ? r : NULL;
*x = l; *head = p;
return p;
}
/* 包装函数 */
void Sort( node* head )
{
int i;
node tmp = *head;
for ( i = 0; tmp; ++i, tmp = tmp-next );
msort( head, i );
}
int main( void )
{
node head = Create();
Print( head );
Sort( head );
Print( head );
getch();
return 0;
}
望采纳
