c語言動態鏈表排序問題

Ⅰ 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);
}