单链表实现学生成绩的冒泡排序

⑴ C++单链表冒泡排序

|///////////not test
int sort(STUDENT **head)
{
if( head == NULL )
return 0;
if( *head == NULL || (*head)->next == NULL)
return 1;
STUDENT *p = *head,*f = NULL;
while( p->next != NULL)
{
STUDENT *q = p->next,*t = p->next->next;
while(t != NULL){
if( q->ave < t->ave) q = t;
t = t->next;
}
if( p->ave < q->ave)
{
if(p == *head){
t = p->next;
p->next = q->next;
q->next = t;
*head = q;
p = q;
}else{
f->next = q;
t = p->next;
p->next = q->next;
q->next = t;
p = q;
}
}
f = p;p = p->next;

}
}

⑵ 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语言链表学生信息管理系统，使用的是冒泡排序，但是执行顺序不同，结果就不同

structStudent*sort1(structStudent*head){
	structStudent*p,*pt,*q;
	p=(structStudent*)malloc(LEN);//临时头结点
	p->next=head;//添加到链表的首部
	head=p;//保存链表的头结点地址
	p=head;//为排序做准备
	while(p->next!=NULL){
		q=p->next;
		while(q->next!=NULL){
			if(p->next->all<q->next->all){
				pt=p->next;
				p->next=q->next;
				q->next=p->next->next;
				p->next->next=pt;
			}
			elseq=q->next;
		}
		p=p->next;
	}
	p=head;
	head=head->next;
	free(p);
	p=NULL;
	returnhead;
}

⑷ 求单链表冒泡排序程序

如果数据比指针大的多交换结点，否则交换数据，其他和数组排序差别不大！内！
注意，链表是双层容的数据结构，结点内包含数据是一层，若干结点组合成一个链表又是 一层的数据结构，即可以把结点内的数据当作一个元素进行排序，又可以把整个结点当作一个整体进行排序！当数据本身比指针大很多时交换数据，效率比交换结点低多了！虽然文换结点，略有些麻烦也很容易解决，只要查找前一个结点即可！找一个数组排序，略加修改即可！

⑸ 单链表冒泡排序

你先把冒泡排序弄出来，这是必须的 冒泡排序弄成子函数 在你输入数之后，在用一个函数判断你的getchar()内容是y还是n，之后条件跳转到冒泡还是直接输出结果

⑹ 数据结构之单链表冒泡排序

void BubbleSort( sNode R[])
{
ElemType temp;
int i,j,flag;
for(i=0;i<n-2;i++)
{
flag=true;
for(j=i+1;j<n-2;j++)
{
if(R[j].age>R[j+1].age)
{
temp=R[j];
R[j]=r[j+1];
R[j+1]=temp;
flag=false;
}
}
if(flag) break;
}
}

⑺ 急！！求c语言单链表冒泡排序的详细流程图

#include<stdio.h> #include<malloc.h> struct number { int num; struct number *next; }; void main() { struct number *head; struct number *p1,*p2,*p,*p3,*p4; int n=0,m,i,j; p1=p2=(struct number *)malloc(sizeof(struct number)); printf("\nWang jianfei 060806110006\n\n\n"); printf("Please enter the number: \n"); scanf("%d",&p1->num); head=NULL; while(p1->num!=NULL) { n=n+1; if(head==NULL) head=p1; else p2->next=p1; p2=p1; p1=(struct number *)malloc(sizeof(struct number)); scanf("%d",&p1->num); } p2->next=NULL; p=head; for(p4=head;p4!=NULL;p4=p4->next) { for(p3=head;p3->next!=NULL;p3=p3->next) { if(p4->num>p3->num) { m=p4->num; p4->num=p3->num; p3->num=m; } } p=head; } printf("\nNow,there %d numbers are: ",n); p=head; printf("\n"); if(head!=NULL) do { printf("%5d ",p->num); p=p->next; }while(p!=NULL); printf("\n"); getch(); }

⑻ C语言链表冒泡排序

我这个效率要高一些，呵呵。

#include <stdio.h>

typedef struct listnode
{
int f;
struct listnode *next;
} ListNode;

ListNode *sort(ListNode *head)
{
ListNode *p,*p1,*p2,*p3;
ListNode h, t;
if (head == NULL) return NULL;
h.next=head;
p=&h;
while (p->next!=NULL)
{
p=p->next;
}
p=p->next=&t;
while (p!=h.next)
{
p3=&h;
p1=p3->next;
p2=p1->next;
while (p2!=p)
{
if ((p1->f)>(p2->f))
{
p1->next=p2->next;
p2->next=p1;
p3->next=p2;

p3=p2;
p2=p1->next;

} else {
p3=p1;
p1=p2;
p2=p2->next;
}
}
p=p1;
}
while (p->next!=&t)
{
p=p->next;
}
p->next=NULL;
return h.next;
}

int main() {
ListNode h,j,k,l;
h.next=&j;
h.f=3;
j.next=&k;
j.f=5;
k.next=&l;
k.f=1;
l.next=NULL;
l.f=7;
ListNode* p = sort(&h);
while (p != NULL) {
printf("%d ", p->f);
p=p->next;
}
printf("\n");
return 0;
}

⑼ C语言链表如何实现冒泡排序

两种 思路：
1、交换链表中各节点的数据，不交换节点；
2、交换节点，即回节点link指针答的内容。
下面以第一种思路为例：
void sort(LinkList *L)
{
int i,j,t;
LinkList *p = L;
int count = 0;
while(p->link != NULL)
{
count++;
p = p->link;
}
for(i=0;i<count-1;i++) /* 冒泡法排序 */
{
p = L;
for(j=0;j<count-i-1;j++)
{
if(p->data > p->link->data)
{
t=p->data;
p->data = p->link->data;
p->link->data=t;
}
p = p->link;
}
}
}