Ⅰ c语言链表如何排序
可以把链表设计成循环链表，用冒泡排序
在排序前设计一个交换标记，如在循环过程中有交换，则修改这个标记变量，如果在一次循环（当前节点为刚开始时节点，表示循环了一次）中，交换标记没有被修改，则表明该数列已排好序。
现在给一个双向循环链表的排序程序给你，该程序用了双向冒泡排序（也就是鸡尾酒排序法），希望对你有帮助
双向链表我用的鸡尾酒排序,也就是双向冒泡排序
#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=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语言动态链表排序问题，交换指针出错
错误出在你在HI给我的菜单函数中，我当时给你的主函数是：
int main()
{
struct course *p;
p=creat();
print(p);
p=sort(p);
print(p);
system("pause");
return 0;
}
而你的菜单函数的switch部分是：
switch(choice)
{
case 1:head=creat(); break; //输入
case 2:print(head);system("PAUSE"); break; //输出
case 7:sort(head);print(head);system("PAUSE"); break; //顺序
}
错误就出在 case 7:sort(head);print(head);system("PAUSE"); break;
sort(head)返回了排序后链表的头指针，但是你的head指针却没有更新，依然是排序前的头指针，在你的输入里，也就是2那一项，如果你的第一项是3，那么只会从3那一项开始输出，就只有2项了。
所以应该这么写head=sort(head);把新的头指针赋给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；
｝
(3)c语言动态链表排序问题扩展阅读：
return表示把程序流程从被调函数转向主调函数并把表达式的值带回主调函数，实现函数值的返回，返回时可附带一个返回值，由return后面的参数指定。
return通常是必要的，因为函数调用的时候计算结果通常是通过返回值带出的。如果函数执行不需要返回计算结果，也经常需要返回一个状态码来表示函数执行的顺利与否（-1和0就是最常用的状态码），主调函数可以通过返回值判断被调函数的执行情况。
Ⅳ c语言动态链表排序问题
p2.next是否依然对应p3？还是p1.next对应p3？那么看来你的p1,p2是结构体变量，而不是结构体指针变量；
对于链表排序注意有2种；一种是改变节点的指向；还有一种就是改变结构体成员的内部保存的数据；通常用第一种；
Ⅳ C语言 关于链表的排序问题
//注意看注释的几句话
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
struct paixu
{
int a;
struct paixu *next;
};
typedef struct paixu Q;
void charu(Q *m,Q *&head)
{
Q *p,*n,*k;
int d,x;
n=(Q *)malloc(sizeof(Q));
n=m;
p=head;//同时p也应该赋初值
k=head->next;//这儿原来是k=head;
x=n->a;
for(;k!=NULL;k=p->next)//第一个数是不能插进去的，因为head->next==NULL
{
d=k->a;
if(x>d)
{
n->next=k;
p->next=n;
break;
}
p=k;
}
if(k==NULL)//对于最开始没有数据结点的时候，就会执行if里面的内容，而对于当前的数比链表内的书都小的话也会执行这个
{
n->next=k;
p->next=n;
}
}
void chu(Q *head)
{
Q *p;
p=head->next;
while(p!=NULL)
{
printf("%d ",p->a);
p=p->next;
}
printf("\n");
}
int main()
{
Q *head,*end,*m;
int q,w,e;
end=NULL;
head=(Q *)malloc(sizeof(Q));
head->next=end;
head->a=0;
for(;;)
{
m=(Q *)malloc(sizeof(Q));
scanf("%d",&m->a);
if(m->a==0)
break;
charu(m,head);
}
chu(head);
getch();
return 0;
}
Ⅵ C语言 链表如何进行排序！
//排序( 参数为链表头 )
void Sorting( student* pHead )
{
//参数判断(如果是空就返回)
if ( pHead == NULL )
{
return;
}
//临时变量..做冒泡循环用..
student* pTempA = pHead;
student* pTempB = pHead;
//这两个while相当于冒泡的嵌套for循环
while( pTempA != NULL )
{
while ( pTempB != NULL )
{
//判断结构体里面int类型(学号)大小
if ( pTempA->iNum < pTempB->iNum )
{
//将结构体里int类型(学号)值进行交换
int Num = pTempA->iNum;
pTempA->iNum = pTempB->iNum;
pTempB->iNum = Num;
//将char类型(名字)做交换
char Name[ 16 ];
strcpy ( Name, pTempA->strName );
strcpy ( pTempA->strName, pTempB->strName );
strcpy ( pTempB->strName, Name );
//因为指针变量不做交换...所以不做结构体的直接交换
//除了指向下一个结点的指针变量外所有的值进行交换
}
//做链表遍历(相当于循环的i++)
pTempB = pTempB->pNext;
}
//因为for每次进来i = 0; 这里while循环结束..要让pTempB重新回到头..
pTempB = pHead;
//做链表遍历(相当于循环的i++)
pTempA = pTempA->pNext;
}
}
连接晚上回来给你写...
Ⅶ 编程：C语言，动态链表中的数字排序和删除问题
#include<stdio.h>
#defineMAX1024
structNode
{
intvalue;
structNode*next;
};
structNode*head=NULL;
intGetNextStart(char*st,intlast,intlen)
{
inti;
for(i=last;i<len;i++)
{
if(st[i]==',')
returni+1;
}
returnlen+1;
}
voidDoWithValue(intvalue)
{
structNode*pCur=head,*plast=NULL;
if(head==NULL)
{
//没有节点，直接插入；
pCur=(structNode*)malloc(sizeof(structNode));
pCur->value=value;
pCur->next=NULL;
head=pCur;
return;
}
else
{
while(pCur!=NULL&&value>pCur->value)
{
plast=pCur;
pCur=pCur->next;
}
if(pCur!=NULL&&value==pCur->value)
{
//删除
if(plast==NULL)
{
//删除的是第一个节点
head=pCur->next;
free(pCur);
}
else
{
//删除的不是第一个节点
plast->next=pCur->next;
free(pCur);
}
}
else
{
//插入
structNode*pNew=(structNode*)malloc(sizeof(structNode));
pNew->value=value;
if(plast==NULL)
{
//插入位置是第一个节点
pNew->next=head;
head=pNew;
}
else
{
//插入位置不是第一个节点
pNew->next=plast->next;
plast->next=pNew;
}
}
}
}
voidShowAllList()
{
structNode*p=head;
printf("ValuesofList: ");
while(p!=NULL)
{
printf("%d",p->value);
p=p->next;
}
printf(" ");
}
voidDelAllList()
{
structNode*p=head,*plast=NULL;
while(p!=NULL)
{
plast=p;
p=p->next;
free(plast);
}
}
intmain()
{
charstInput[MAX],ch;
inti=0,curStart=0,curEnd,nextStart,len;
intvalue;
printf("Pleaseinputalineofnumbers,splitwith[,]: ");
while((ch=getchar())!=' ')
{
stInput[i++]=ch;
}
stInput[i]=' ';
len=strlen(stInput);
while(curStart<len)
{
nextStart=GetNextStart(stInput,curStart,len);
curEnd=nextStart-1;
stInput[curEnd]=' ';
value=atoi(stInput+curStart);
DoWithValue(value);
curStart=nextStart;
}
ShowAllList();
DelAllList();
}
Ⅷ C语言链表的排序问题...高奖励
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
你的sort1,sort2未作NULL判定就直接用sort1 -> next,sort2 -> next;来赋值，这是很危险的。
sort1 = head ; //初始化三个变量为链表前三个结点
sort2 = sort1 -> next;
sort3 = sort2 -> next;
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
经过了while循环,sort3此时很可能是NULL,sort3 -> score会报使用空指针错误。
这个地方好象有问题啊，sort3->next和sort1->next都指向同一个节点，而且都是sort3节点，数据链在这里断了，sort2节点丢了？sort3->next后面的节点也丢了？如果是处理sort3==NULL的情况，那判断(sort2->score >= sort3 -> score )还有意义吗？
// if ( sort3 = NULL)
{
if(sort2->score >= sort3 -> score )
{
sort1->next = sort2 ->next ;
sort3->next = sort1 ->next ;
sort2->next = NULL ;
}
}
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
你的排序象是用的沉底法，但你的代码逻辑好象有问题，也许是你没有完全贴上来？
你的for循环把一个最大数放到了链尾，然后跳出了循环，接着while也会跳出循环，
是否可以解决您的问题？
Ⅸ 是C语言，我要具体的动态链表的排序方法，是交换结构体里的指针，
可以试试这段代码
#include<stdio.h>
#include<malloc.h>
typedefstructnode
{
intdata;/*data代表成绩分数*/
structnode*next;
}LNode,*LinkList;
LinkListCreat(void)/*创建链表，结束标志为当输入的数据为0!*/
{
LinkListH,p1,p2;
intn;
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);
}
LinkListSort(LinkListSL)/*递增排序函数：入口参数：链表的头指针，此为链表中的排序函数*/
{
LinkListp,q;
inttemp;
for(p=SL;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;
}
}
}
returnSL;
}
intmain()
{
LinkListL,S,K;
L=Creat();
printf("初始化的单链表数据序列为: ");
for(S=L;S!=NULL;S=S->next)
printf("%d",S->data);
Sort(L);
printf(" 按递增顺序排序后的序列为: ");
for(K=L;K!=NULL;K=K->next)
printf("%d==>",K->data);
return0;
}
Ⅹ 关于C语言链表排序的问题
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
structnumber//链表节点
{
intnum;
structnumber*next;
};
intn;
structnumber*creat()//创建链表
{
structnumber*head;//头节点
structnumber*p1,*p2;
n=0;
p1=p2=(structnumber*)malloc(sizeof(structnumber));
scanf("%d",&p1->num);
head=NULL;
while(p1->num!=0)//循环输入链表数据，当输入为0时结束，链表数据不包括0
{
n=n+1;
if(n==1)
head=p1;
else
p2->next=p1;
p2=p1;
p1=(structnumber*)malloc(sizeof(structnumber));
scanf("%d",&p1->num);
}
p2->next=NULL;
return(head);
}
voidprint(structnumber*head)//链表从小到大排序，并输出
{
structnumber*p1,*p2,*p;
inti,j,t;
printf("这%d个数从小到大的排序为： ",n);
if(head!=NULL)
{
//冒泡排序
for(j=0;j<n-1;j++)
{
p1=head;p2=head;
for(i=0;i<n-1-j;i++)
{
p2=p1->next;
if(p1->num>=p2->num)
{
t=p1->num;
p1->num=p2->num;
p2->num=t;
}
p1=p1->next;
}
}
}
p=head;
if(head!=NULL)
{
//输出链表值
do
{
printf("%3d",p->num);
p=p->next;
}while(p!=NULL);
}
}
voidmain()
{
structnumber*head;
head=creat();
print(head);
}