c語言鏈表的排序
㈠ 在數據結構中用c語言怎麼編寫用單鏈表將26個字母排序的程序
#include <stdio.h>
#include <stdlib.h>
//申明鏈表
typedef struct node
{
char num;
struct node *next;
}list;
void Bubble_sort(list *L);//鏈表的冒泡排序
void Dis_list(list *L);//遍歷單鏈表
int main()
{
//建表
list *r,*s,*p;
int n=26;//存儲數據的個數
s=NULL;
for(int i='Z';i>='A';i--)
{
r=(list *)malloc(sizeof(list));
r->num = i;
if(!s){s=r;p=s;}
p->next=r;
p=r;
}
p->next=NULL;
printf("排序前:\t");
Dis_list(s);
//排序
Bubble_sort(s);
printf("排序後:\t");
Dis_list(s);
return 0;
}
void Dis_list(list *L)
{
list *r;
r=L;
while(r!=NULL)
{
printf("%c\t",r->num);
r=r->next;
}
printf("\n");
}
void Bubble_sort(list *L)
{
list *r,*s;
char temp;
for(r=L;r;r=r->next)
{
for(s=r;s;s=s->next)
{
if(r->num>s->num)
{
temp=r->num;
r->num=s->num;
s->num=temp;
}
}
}
}
㈡ c語言鏈表插入法求解下列問題
根據題意：
一、鏈表創建：根據輸入的數字，動態創建任意多個節點插入鏈表。（題目規定n<=40，如不想使用malloc動態申請內存，需直接定義最大上限40個節點）。
二、鏈表排序：交換節點內容（不是地址），保留鏈表指針的值（*next的值）。
三、列印鏈表：利用鏈表指針遍歷鏈表。
四、對動態申請的鏈表地址空間釋放（在本程序中創建後程序就結束了，即使不寫free釋放，結束後也會釋放。但在復雜程序中調用創建，後續還有代碼，需像我代碼中寫函數動釋放不用的內存，避免浪費）。
下面是代碼：
#include <stdio.h>
#include <malloc.h>
typedef struct numStruct
{
int num;
struct numStruct *next;
}NST;
NST *insert2List(int num);//根據數字創建節點（動態），插入鏈表（首次自動生成頭節點），成功返回頭節點，失敗返回NULL。
void showList(NST *nsthead);//列印鏈表
void px(NST *nsthead);//鏈表排序
void freeList(NST *nsthead);//釋放鏈表內存
int main()
{
NST *nsthead=NULL;
int i=0,n=50,*nums=NULL;
while(n>40)
scanf("%d",&n);
nums=(int *)malloc(sizeof(int)*n);
if(!nums) return 1;
while(i<n)
scanf("%d",&nums[i++]);
i=0;
while(i<n)
nsthead=insert2List(nums[i++]);
px(nsthead);
showList(nsthead);
freeList(nsthead);
return 0;
}
void freeList(NST *nsthead)
{
NST *temp=NULL,*nst=NULL;
if(nsthead)
{
nst=nsthead->next;
while(nst!=NULL)
{
temp=nst;
nst=nst->next;
free(temp);
}
}
free(nsthead);
}
void showList(NST *nsthead)
{
if(nsthead)
while(nsthead->next!=NULL)
{
printf("%d ",nsthead->next->num);
nsthead=nsthead->next;
}
printf(" ");
}
void px(NST *nsthead)
{
NST *nt1=NULL,*nt2=NULL,ntTemp,*nextSave=NULL;
if(nsthead)
{
nt1=nsthead->next;
while(nt1)
{
nt2=nt1->next;
while(nt2)
{
if(nt1->num>nt2->num)
{
ntTemp=*nt1;
nextSave=nt1->next;
*nt1=*nt2;
nt1->next=nextSave;
nextSave=nt2->next;
*nt2=ntTemp;
nt2->next=nextSave;
}
nt2=nt2->next;
}
nt1=nt1->next;
}
}
}
NST *insert2List(int num)
{
static NST *nsthead=NULL,*nstTail=NULL;
NST *nstNew=NULL;
nstNew=(NST *)malloc(sizeof(NST));
if(!nstNew) return NULL;
nstNew->next=NULL;
nstNew->num=num;
if(!nsthead)
{
nsthead=(NST *)malloc(sizeof(NST));
if(!nsthead) return NULL;
nsthead->next=nstNew;
}
else
nstTail->next=nstNew;
nstTail=nstNew;
return nsthead;
}
㈢ C語言：單鏈表排序 有三個單鏈表程序 想知道每句運行下的意思（演算法）
1：Linklist * inserSort(Linklist *L) /*函數參數是一個鏈表的指針L，返回的也是這個指針，是排序好了的鏈表。*/
2：{
3： Linklist *p=L->next;/*p指向鏈表第一個節點。*/
4： Linklist *r;
5： Linklist *q;
6： int i;
7： int j;
8： int x;
9： int n=lengList(L);/*獲取鏈表的節點總個數，存入n。*/
10： for(i=1;i<n;i++)/*這個for循環配合23行，讓p依次指向鏈表的第1個節點到倒數第2個節點。
這顯而易見啊：循環了n-1次，每次都執行23行「p=p->next」。*/
11： {
12： q=p->next;/*讓q指向p的下一個節點*/
13： for(j=i+1;j<=n;j++)/*12行、這行的for循環和21行，讓q依次指向p之後的節點一直到鏈表末尾。*/
14： {
15： if(p->data>q->data) /*看p中的數據是否比q中的大*/
16： {
17： x=p->data; /*這17，18，19三行是交換pq兩節點的數據*/
18： p->data=q->data; /**/
19： q->data=x; /**/
20： }
21： q=q->next;
22： }
23： p=p->next;
24： }
25： return L;
26：}
以下是上面解釋的動態例子：括弧中是鏈表節點的數據，共4個節點，用1234標明。
1(5)->2(8)->3(2)->4(7)
i=1時：p->1(5)
j=2時：
p->1(5),q->2(8),if不成立，q->3(2)
j=3時：
p->1(5),q->3(2),if成立，交換，鏈表為1(2)->2(8)->3(5)->4(7),q->4(7)
j=4時：
p->1(2),q->4(7),if不成立q->5(null)
i=2時: p->2(8)
j=3時:
p->2(8),q->3(5),if成立，交換，鏈表為1(2)->2(5)->3(8)->4(7),q->4(7)
j=4時:
p->2(5),q->4(7),if不成立，q->5(null)
i=3時：p->3(8)
j=4時：
p->3(8),q->4(7),if成立，交換，鏈表為1(2)->2(5)->3(7)->4(8),q->5(null)
至此，排序流程走完，鏈表從5827排成了2578。
很不好意思，筆者由於重重原因現在僅能完成第一部分，希望能幫上你。