① 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;
}
}
連接晚上回來給你寫...