① c语言单向链表排序如何实现
struct student* printf_sort(struct student *head)
{
struct student *p1,*p2,*ptemp,*pfinished=NULL;
for(p1=head;p1->next!=pfinished;)//对链表进行从大到小排序（这里用冒泡法）
//p1使之总是指向头结点，pfinished使之总是指向已排序好的最前面的结点
//ptemp作为中介，保存p2的上一个结点
{
for(p2=p1;p2->next!=pfinished;)
{
if(p2->num<p2->next->num)//p2的值小于p2->next的值，交换 {
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语言中的链表排序是如何实现的
用冒泡排序的方法，各种方法都可以啊
③ C语言如何对链表的数进行排序
同学，给你一段代码，里面涵盖了链表的冒泡排序！
#include<stdio.h>
#include<malloc.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->data>q->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语言链表如何排序
可以把链表设计成循环链表，用冒泡排序
在排序前设计一个交换标记，如在循环过程中有交换，则修改这个标记变量，如果在一次循环（当前节点为刚开始时节点，表示循环了一次）中，交换标记没有被修改，则表明该数列已排好序。
现在给一个双向循环链表的排序程序给你，该程序用了双向冒泡排序（也就是鸡尾酒排序法），希望对你有帮助
双向链表我用的鸡尾酒排序,也就是双向冒泡排序
#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语言 链表怎么排序 急求大虾
排序！这是一个庞大的话题，有插入排序，插入排序又分直接插入排序、希尔排序等，还有交换排序，交换排序有冒泡排序、快速排序，还有选择排序，有直接选择排序、归并排序等等…而且还不断的有新的排序方法产生…不知道你要哪一种…新手一般用选择排序和冒泡排序，方法简单，两重循环。
⑥ C语言 单向链表如何排序
void link_order(STU *p_head)
{
STU *pb, *pf, temp;
pf = p_head;
if(p_head == NULL) {//链表为空
printf("needn't order. ");
return ;
}
if(p_head->next == NULL) {//链表有1个节点
printf("only one print, needn't order. ");
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 ;
}
(6)c语言实现内核链表排序扩展阅读：
链表的排序有三种情况：
1、链表为空时：不用排序；
2、链表中有一个节点：不用排序；
3、链表中两个及其以上节点时：排序。
return 0代表程序正常退出。return是C++预定义的语句，它提供了终止函数执行的一种方式。当return语句提供了一个值时，这个值就成为函数的返回值。
return语句用来结束循环，或返回一个函数的值。
1、return 0，说明程序正常退出，返回到主程序继续往下执行。
2、return 1，说明程序异常退出，返回主调函数来处理，继续往下执行。return 0或return 1对程序执行的顺序没有影响，只是大家习惯于使用return(0)退出子程序而已。
⑦ 链表选择排序的C语言算法实现
common.h
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
linklist.h
#include common.h
typedef int ElemType;
typedef struct Node /*结点类型定义*/
{
ElemType data;
struct Node * next;
}Node, *LinkList; /* LinkList为结构指针类型*/
void CreateFromTail(LinkList L)
{
Node *r, *s;
char c;
int flag =1; /*设置一个标志，初值为1，当输入$时，flag为0，建表结束*/
r=L; /*r指针动态指向链表的当前表尾，以便于做尾插入，其初值指向头结点*/
while(flag) /*循环输入表中元素值，将建立新结点s插入表尾*/
{
c=getchar();
if(c!='$')
{
s=(Node*)malloc(sizeof(Node));
s->data=c;
r->next=s;
r=s;
}
else
{
flag=0;
r->next=NULL; /*将最后一个结点的next链域置为空，表示链表的结束*/
}
}
} 尾插法创建链表程序
/*_*====尾插法创建链表，返回链表头指针====*_*/
LinkList CreateFromTail2()
{
LinkList L;
Node *r, *s;
int c;
int flag =1;
L=(Node * )malloc(sizeof(Node));
L->next=NULL;
r=L;
while(flag)
{
scanf(%d,&c);
if(c!=-1)
{
s=(Node*)malloc(sizeof(Node));
s->data=c;
r->next=s;
r=s;
}
else
{
flag=0;
r->next=NULL;
}
}
return L;
} void linkSort(LinkList l)
{
Node *p,*q,*m,*n;
Node *temp1,*temp2;
if(l->next==NULL)
printf(NO LINKLIST!!!);
else
{
p=l;q=l->next;
while(q->next!=NULL)
{
m=p->next;
n=q->next;
temp1=m;
while(temp1->next!=NULL)
{
if(temp1->next->data<q->data && temp1->next->data<n->data)
{
m=temp1;n=temp1->next;
}
temp1=temp1->next;
}/*_*====此循环用于找到基准(q)以后的序列的最小的节点=====*_*/
if(m!=p->next || (m==p->next && m->data>n->data))
{
p->next=n;
p=n;
m->next=q;
m=q;
q=q->next;
n=n->next;
p->next=q;
m->next=n;
}/*_*======此条件用于交换两个节点*_*/
else
{
p=p->next;
q=q->next;
}/*_*======此条件用于没有找到最小值时的p，q后移操作*_*/
}/*_*=====外循环用于从前往后扫描，通过移动p,q指针实现=======*_*/
temp2=l->next;
printf(List after sorting is:
);
while(temp2!=NULL)
{
printf(%5d,temp2->data);
temp2=temp2->next;
}
}
printf(
);
} void main()
{
Node *temp3;
LinkList l;
printf( =====(end by -1)======
press enter after input the nember each time:
);
l=CreateFromTail2();
temp3=l->next;
if(temp3==NULL)
printf(NO LINKLIST!!!);
else
{
printf(List before sorting is:
);
while(temp3!=NULL)
{
printf(%5d,temp3->data);
temp3=temp3->next;
}
}
printf(
);
linkSort(l);
}
⑧ C语言链表中如何实现对一组数据进行排序
这个是我曾经编写的一个管理里面的一个模块
就是按链表的某个变量进行排序的
希望您能看明白
Ranking_inquires(struct
student
*head)
{
int
B=A,i=0;
struct
student
*temp=head;
struct
student
*p=head;
struct
student
*q=head;
printf("\t\t
按总分
名次查询
\n
");
printf("姓名
总分
名次\n");
while(p->next!=NULL&&A>1)//根据成员的成绩对结构体
进行排序
{
p->sum=p->math+p->English+p->chinese+p->computer;
q=p->next;
p=p->next;
while(q->next!=NULL)
{
q=q->next;
if(p->sum
sum)
{
h.stu_id1=p->stu_id;
strcpy(h.name1,p->name);
h.English1=p->English;
h.computer1=p->computer;
h.math1=p->math;
h.sum1=p->sum;
h.chinese1=p->chinese;
p->stu_id=q->stu_id;
strcpy(p->name,q->name);
p->English=q->English;
p->computer=q->computer;
p->math=q->math;
p->sum=q->sum;
p->chinese=q->chinese;
q->stu_id=h.stu_id1;
strcpy(q->name,h.name1);
q->English=h.English1;
q->computer=h.computer1;
q->math=h.math1;
q->sum=h.sum1;
q->chinese=h.chinese1;
}
}
A--;
++i;
p->ranking=i;
}
这个是定义的全局变量
int
A=0;
int
cc;
struct
student
{
int
stu_id;
char
name[20];
float
English;
float
computer;
float
chinese;
float
math;
float
sum;
int
ranking;
struct
student
*next;
};
struct
stu
{
int
stu_id1;
char
name1[20];
float
English1;
float
computer1;
float
chinese1;
float
math1;
float
sum1;
}h;
⑨ c语言链表排序
#include<stdio.h>
#include<malloc.h>
#define OK 1
#define ERROR 0
typedef long LElemType; //学号变量类型
typedef float FElemType; //成绩变量类型
typedef int Status; //返回值的类型
typedef struct student
{
LElemType num;
FElemType score;
student *next;
}node;
typedef struct LIST
{
node *head,*tail;
}link;
node *MakeNode(long num, float score) //生成存放学生信息的节点
{
node *p=(node *)malloc(sizeof(node));
p->num = num; //存放学号
p->score = score; //存放分数
p->next = NULL; //刚生成的节点下一个为空
return p;
}
Status Create(link *s,int n)
{
long num;
float score;
s->head = s->tail = MakeNode(0,-1); //头结点num用来存放学生信息条数。score空着不用
if(NULL == s->head)
{
puts("分配失败!");
return ERROR;
}
for(int i=0; i<n; i++) //录入n个学生的信息
{
printf("请输入第%d个学生的信息(学号与成绩): ",i);
scanf("%d%f",&num,&score);
node *p = MakeNode(num,score);
s->tail->next = p;
s->tail = p;
s->head->num++; //修改头结点中存放学生信息条数每增加一个节点就要++1
}
return OK;
}
Status display(link *s)
{
node *p = s->head->next; //让p指针指向头结点的下一个节点，因为头结点只用来存放了学生的人数
while(p)//只要p指针指向不为空就要输出
{
printf("%d %.2f\n",p->num,p->score);
p = p->next;
}
return OK;
}
//按照成绩升序排序
Status SortByScore(link *s)
{
int n = s->head->num;
node *p,*cur,*next;
for(int i=0; i<n-1; i++)
{
p= s->head;
cur=p->next;
next = cur->next;
for(int j=0; j<n-1-i; j++)
{
if(next->score<cur->score)
{
p->next=next;
cur->next = next->next;
next->next = cur;
p=next;
next=cur->next;
}else{
p=cur;
cur = next;
next = next->next;
}
}
}
return OK;
}
int main()
{
link s;
int n;
printf("你想录入多少学生的记录：n=");
scanf("%d",&n);
Create(&s,n);
puts("所有学生的信息(学号与成绩): ");
display(&s);
SortByScore(&s);
puts("按成绩升序排序好的所有学生的信息(学号与成绩): ");
display(&s);
return OK;
}
⑩ 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;
}
}
连接晚上回来给你写...