c語言鏈表排序
⑴ 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語言用鏈表排序：下面是代碼
修改 create 方法就可以了，其實更好的的是 n 個輸入都在循環里寫，你現在這種寫法，不是好的程序，只是把任務完成了。另外， 全局變數 n 的定義也不好，它本來表示鏈表的長度，但確是用下標表示的。
link creat()
{
link New=NULL;
link Old=NULL; /// 最後一個
link ahead=NULL; /// 最前一個
New=Old=(link)malloc(sizeof(node));
//New->next=NULL;
int i=0;
printf("Please input 5 numbers:");
scanf("%d",&New->age);
for(i=0;i<4;i++)
{
n++;
/* if(n==1)
ahead=New;
else
Old->next=New;
Old=New;
New=(link)malloc(sizeof(node));
這段代碼邏輯不多，改為下面幾行
*/
if(n==1)
ahead=New;
Old=New;
New=(link)malloc(sizeof(node));
Old->next = New;
scanf("%d",&New->age);
}
New->next=NULL;
return ahead;
}
⑶ 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語言如何給鏈表排序
就像數組排序一樣啊，
⑸ C語言,鏈表怎麼從大到小排序
汗！你插入節點時干什麼去了？？？
用鏈表不用數組基本上就是為了兩件事：
不受數組大小的限制、不需要「排序」（如果各個節點可以進行排序的話）
所以，如果你先把節點都一口氣插入到了鏈表裡，再考慮如何進行排序的話，那麼你使用鏈表的意義已經喪失了一半！而且鏈表排序的效率明顯不及數組。故建議你在插入新節點的時，應將其插入到「適當」位置，這樣在增加新節點的同時，還能保證鏈表有序，因此根本不需要在後面進行排序！
修改你的插入節點的演算法吧！雖然每次插入節點稍微麻煩些，但也絕對比你先一口氣插入了全部節點再排序高效的多！
⑹ C語言做鏈表的排序
主要修改了sort函數，採用冒泡排序演算法進行排序的。
你其他的兩個函數寫的不錯，就sort函數寫的有問題，已經很不錯了。
注意：程序結束，最好對鏈表進行銷毀，否則，內存永遠也不會釋放，導致內存泄漏了。
修改如下：
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>
#define N 5
typedef struct node
{
char name[20];
int score;
struct node *link;
}stud;
stud *sort(stud *head) /*排序函數*/
{
stud *temp=NULL; //默認為NULL,也就是鏈表的結尾
stud *ptr1=head;
stud *ptr2=head->link;
while(ptr1->link!=temp)//(ptr1!=NULL)
{
//ptr2=ptr1->link; //放在循環體下面了
while(ptr2->link!=temp)//(ptr2!=NULL)
{
if(ptr1->link->score > ptr2->link->score) //(ptr1->score > ptr2->score)
{//交換 ptr1->link和ptr2->link，而不是ptr1和ptr2，否則無法交換
ptr1->link=ptr2->link;
ptr2->link=ptr2->link->link;//temp->link=ptr2;
ptr1->link->link=ptr2;//ptr2->link=ptr1;
}
ptr1=ptr1->link;//ptr2=ptr2->link;
ptr2=ptr1->link;//從上面移動下來的
}
temp=ptr2;//新加的
ptr1=head;//ptr1=ptr1->link;
ptr2=ptr1->link;//從上面移動下來的
}
return (head);
}
stud * creat(int n)
{
stud *p,*h,*s;
int i;
if((h=(stud *)malloc(sizeof(stud)))==NULL)
{
printf("不能分配內存空間!");
exit(0);
}
h->name[0]='\0';
h->link=NULL;
p=h;
for(i=0;i<n;i++)
{
if((s= (stud *) malloc(sizeof(stud)))==NULL)
{
printf("不能分配內存空間!");
exit(0);
}
s->link=NULL;//p->link=s; //跟下句對調了一下，為了把相關的代碼放在一起
printf("請輸入第%d個人的姓名",i+1);
scanf("%s",s->name);
printf("請輸入第%d個人的分數",i+1);
scanf("%d",&s->score);
p->link=s; //s->link=NULL;//跟上句對調了一下，為了把相關的代碼放在一起
p=s;
}
return(h);
}
void print(stud *h)
{
stud *p;
p=h->link;
printf("數據信息為：\n");
while(p!=NULL)
{
printf("%s ",&*(p->name));
printf("的分數為%d\n",p->score);
p=p->link;
}
}
void main()
{
stud *head;
head=creat(N);
head=sort(head);
print(head);
getchar();
}
⑺ 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 ;
}
(7)c語言鏈表排序擴展閱讀：
鏈表的排序有三種情況：
1、鏈表為空時：不用排序；
2、鏈表中有一個節點：不用排序；
3、鏈表中兩個及其以上節點時：排序。
return 0代表程序正常退出。return是C++預定義的語句，它提供了終止函數執行的一種方式。當return語句提供了一個值時，這個值就成為函數的返回值。
return語句用來結束循環，或返回一個函數的值。
1、return 0，說明程序正常退出，返回到主程序繼續往下執行。
2、return 1，說明程序異常退出，返回主調函數來處理，繼續往下執行。return 0或return 1對程序執行的順序沒有影響，只是大家習慣於使用return(0)退出子程序而已。
⑻ C語言中的鏈表排序問題
link sort(link head) //head為表頭結點
{
link beforep,p,p1,k,beforek,temp;
if(head==NULL)printf("信息系統為空!!!按任意鍵回到主菜單!\n"); //表頭節點為空即鏈表為空
else
{p=head; //指針p指向表頭
while(p->next!=NULL) //當鏈表沒有遍歷完執行循環體
{
k=p; //指針k指向指針p
p1=p->next; //指針p1指向指針p的下一個節點
while(p1!=NULL) //當指針p1不為空，執行循環體
{
if(k->aver<p1->aver)k=p1; //這里的k->表示k所指向對象的aver成員
p1=p1->next; //當k指向的aver成員小於p1指向的aver成員，k指向p1
} //這個循環結束後，k將指向鏈表中p之後所有節點的aver成員最小的那個節點，這是插入排序的搜索過程
if(k!=p) //如果aver成員最小的節點不是p所指向的節點
{
beforek=head; //beforek從頭結點往後尋找
while(beforek->next!=k)beforek=beforek->next; //循環結束後，beforek指針將指向k指針的前一個節點，因為條件beforek->next==k 才結束循環
if(p==head)head=k; //如果p是頭結點，頭結點指向k（k是成員aver最小的，排在第一個節點作為頭結點）?
else beforep->next=k; //否則beforep->next指向k，（請注意這里的beforep與剛才的beforek不一樣）
beforek->next=p; //beforek->next指向指針p
temp=k->next;
k->next=p->next;
p->next=temp; //交換k->next和p->next指針
p=k; //p指向k
} //這個函數體運行結束後，p指針指向鏈表aver成員最小的那個節點，這也就是插入排序的交換過程
beforep=p; //指針回指
p=p->next; // 遍歷下一個節點
}
printf("排序成功,按任意鍵回到主菜單!\n");
}
return(head); //返回頭結點
}
如果還是看不懂，你就留Q追問我
⑼ 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語言鏈表排序
void pai(Link i)
{
Link ii;
Node *p,*rr,*s;
p=i->next;
ii=(Link)malloc(sizeof(Node));//用於做新的鏈表
ii->next=NULL;
while(p!=NULL){
s=(Node*)malloc(sizeof(Node));//新建節點用於保存信息
s->next=NULL;
rr=ii;//從這里開始幫我注釋 //rr的作用是指向要比較的結點的指針（新的ii鏈表中），並依次後移，現在是讓它指向頭結點。
while(rr->next!=NULL&&rr->next->data.zong>=p->data.zong)//當rr鏈表中已經有元素了，並且rr指針後移時還沒有指到NULL，其實就是找插入的位置，
rr=rr->next;//如果新的rr鏈表中的值大於或是等於P結點的值，rr指針後移，
if(rr->next==NULL)//因為rr走到頭而退出循環的，說明rr表中的所有結點的值都大於這個值，
rr->next=s;////將這個值直接接在rr鏈表的最後就好了，尾插入法
else //else 語句就是說當rr鏈表中沒有元素時，是個空表的情況
{
s->next=rr->next; //這句是將rr鏈表的尾結點的指針域指向空，
rr->next=s; //把結點s, 結在rr鏈表後，
}//直到這句
p=p->next;
}
free(i);
i->next=ii->next;
printf("\n====>提示：排序已經完成！\n");