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。
很不好意思，笔者由于重重原因现在仅能完成第一部分，希望能帮上你。