谁教我：数据结构的各种排序

Posted 2023-03-03

没好好听老师讲的

讲详细点，追加分
别复制C
我看不懂

1.快速排序

#include"stdio.h"
#define N 100
int a[N]=0;//存放要排序的数

int Qsort(int m,int n)//对数组中m到n的元素进行快速排序

int p,q;
int head,sign;
if(m!=n)//选定的数列不止一个元素

head=a[n];//选择数列的末尾元素作为比较元素
p=m;//p标记数列的首元素
q=n-1;//标记末尾元素的前一个元素
sign=n;//记录比较元素的位置，以其作为空位置
while(p<=q)//分别比较p、q所标记的元素与比较元素的大小，比其小的放在左边，比其大的放在右边

while(a[p]<head)//p所指元素比比较元素小，p右移

p++;
if(p>q)

break;


a[sign]=a[p];//将p所指元素移入空位置
sign=p;//记录空余位置
p++;
if(p>q)

break;

while(a[q]>head)//q所指元素比比较元素大，q左移

q--;
if(p>q)

break;


a[sign]=a[q];
sign=q;
q--;

a[sign]=head;//比较完成后，将比较元素移入空位置
if(sign-1>m)

Qsort(m,sign-1);//对m到sign-1的数列进行排序

if(sign+1<n)

Qsort(sign+1,n);//对sign+1到n的数列进行排序


return(1);


int Print(int m,int n)//对m到n的数组序列输出

int i;
for(i=m;i<=n;i++)

printf("%d\n",a[i]);

return(1);


int main()

int n,i;
scanf("%d",&n);//输入将要排序的数的个数
for(i=0;i<n;i++)

scanf("%d",&a[i]);//输入要排序的数

Qsort(0,n-1);
Print(0,n-1);

二、 详细设计：重要函数中的算法设计，实现流程，传递参数的说明；

三、调试分析与心得体会：
快速排序的思想时从数组序列中选定一个元素，将序列中其余元素与其进行比较，将比其小的放在左边，比其大的放在右边，然后以比较元素为中点，将序列分成两部分，再将它们分别进行快速排序，依次类推，直到序列中只有一个元素为止。

2.合并排序

#include"stdio.h"
#define N 10000
int a[N];//用a数组记录所给无序数列
int b[N]=0;//用b数组记录每次排序之后的a数组
int sign=0;
void Merge(int m,int mid,int n)//将两个有序数列合并成为一个有序数列

int i,j,k;
i=k=m;
j=mid+1;
while(i<=mid&&j<=n)//依次比较两个有序数列中的元素，从大到小将其放入b数组相应位置中

if(a[i]<a[j])

b[k]=a[i];
k++;
i++;

else

b[k]=a[j];
k++;
j++;


if(i<=mid)//将比较之后的剩余元素放入b数组相应位置

while(i<=mid)

b[k]=a[i];
k++;
i++;


else

while(j<=n)

b[k]=a[j];
k++;
j++;


for(i=m;i<=n;i++)//将合并后的数列重新放入a数组相应位置

a[i]=b[i];


int Msort(int m,int n)//对所给无序数列进行排序

int mid;
if(n!=m)

mid=(n+m)/2; //将数列一分为二直到其只有一个元素
Msort(m,mid);
Msort(mid+1,n);
Merge(m,mid,n);//将分割后的数列重新合并起来

return(1);

void Print(int num)//将序列依次输出

int i;
for(i=0;i<num;i++)

printf("%d\n",a[i]);


int main()

int sign;
int i;
int num;
scanf("%d",&num);//输入将要排序的数的个数
for(i=0;i<num;i++)

scanf("%d",&a[i]);//依次输入要排序的数

sign=Msort(0,num-1);
Print(num);//输出完成排序后的有序数列

二、 详细设计：重要函数中的算法设计，实现流程，传递参数的说明；
三、调试分析与心得体会：
合并排序是排序的一种常用方法，其主要思想为：将一个无序数列依次分割直到其每个序列只有一个元素为止，然后再将两个序列合并为一个有序数列，依此类推。

3.我的数据结构实验课题（关于排序）

//问题描述：排序器
//要 求：实现以下六种排序算法，将给定的不同规模大小的数据文件（data01.txt，data02.txt，data03.txt，data04.txt）进行排序，
//并将排序结果分别存储到sorted01.txt，sorted02.txt，sorted03.txt和sorted04.txt文件中。
//1）、Shell排序； 2）、Quick排序
//3）、锦标赛排序； 4）、堆排序
//5）、归并排序； 6）、基数排序
//在实现排序算法1）~4）时，统计数据元素比较的次数和交换的次数，进而对这四种算法在特定数据条件下的效率进行分析和评判。

#include"stdio.h"
#include"math.h"
#include"stdlib.h"
#include"malloc.h"
#define Maxsize 10000000
#define N 20
#define EQ(a,b) ((a)==(b))
#define LT(a,b) ((a)<(b))
#define LQ(a,b) ((a)<=(b))
#define LEN sizeof(SqList)
#define Maxr 10
#define MAXNUM 100000000

typedef struct node
int key;
int num;
;
typedef struct
struct node r[Maxsize+1];
long length;
SqList,*qSqList;
typedef struct node2
struct node r;
struct node2 *next;
RecType;
long shifttimes;//统计移动次数
long comparetimes;//统计比较次数

qSqList creat(char filename[])//读入文件并且将数据保存

FILE *fp;
long i;
qSqList L;
L=(qSqList)malloc(LEN);
L->length=0;
if((fp=fopen(filename,"r"))==NULL)//文件不存在时终止程序

printf("cannot open file\n");
exit(0);

for(i=1;i<Maxsize+1;i++)

fscanf(fp,"%ld (%d)",&(L->r[i].key),&(L->r[i].num));
if(L->r[i].key<0)
break;
L->length++;//记录读入的数据长度

fclose(fp);
return(L);


void Print2(qSqList L)//将序列输出到指定的文件中

long i;
FILE *fp;
char filename[N];
printf("\n\t请输入存储文件名：");
scanf("%s",filename);//输入将要储存的文件名
fp=fopen(filename,"w");
for(i=1;i<=L->length;i++)//将链表中数据逐一写入文件中

fprintf(fp,"%d (%d)\n",L->r[i].key,L->r[i].num);

fclose(fp);


void Print(qSqList L)//打印数据个数以及排序过程中的比较次数和移动次数

printf("\n\t数据个数:%ld",L->length);
printf("\n\t比较次数:%ld",comparetimes);
printf("\n\t移动次数:%ld",shifttimes);


struct node Min1(struct node a,struct node b)//比较两接点关键字的大小

struct node temp;
if(a.key>b.key)
temp=b;
else
temp=a;
comparetimes++;
return(temp);


qSqList shellinsert(qSqList L,int dk)//对顺序表以dk为增量作直接插入排序

int i,j;
for(i=dk+1;i<=L->length;i++)

if(LT(L->r[i].key,L->r[i-dk].key))//将L->r[i]插入到有序增量子表

L->r[0]=L->r[i];//将L->r[i]暂时存储在L->r[0]
shifttimes++;
for(j=i-dk;j>0&<(L->r[0].key,L->r[j].key);j-=dk)//记录后移，查找插入位置

L->r[j+dk]=L->r[j];
comparetimes++;
shifttimes++;

if(j>0)
comparetimes++;
L->r[j+dk]=L->r[0];//插入
shifttimes++;

comparetimes++;

// Print(L);
return(L);


qSqList shell(qSqList L)//希尔排序

int i,t=0;
int k;
for(t=0;LQ(pow(2,t),(L->length+1));t++);
t=t-1;
// printf("%d",t);
for(i=1;i<=t;++i)

k=(int)pow(2,t-i+1)-1;//计算排序增量
L=shellinsert(L,k);

Print(L);
Print2(L);
return(L);


long Quicksort(qSqList L,long low,long high)//交换顺序表L中子表L->r[low..high]的记录，使枢轴记录到位，并返回其所在位置

int pivotkey;
pivotkey=L->r[low].key;//用序列的第一个记录作枢轴记录
while(low<high)//从表的两端交替地向中间扫描

while(low<high&&L->r[high].key>=pivotkey)//将比枢轴记录小的记录交换到低端

comparetimes++;
high--;

comparetimes++;
L->r[0]=L->r[low];
shifttimes++;
L->r[low]=L->r[high];
shifttimes++;
L->r[high]=L->r[0];
shifttimes++;
while(low<high&&L->r[low].key<=pivotkey)//将比枢轴记录大的记录交换到高端

comparetimes++;
low++;

comparetimes++;
L->r[0]=L->r[low];
shifttimes++;
L->r[low]=L->r[high];
shifttimes++;
L->r[high]=L->r[0];
shifttimes++;

return(low);//返回枢轴所在位置


qSqList Quick2(qSqList L,long low,long high)//对顺序表L中的子序列L.r[low..high]作快速排序

long pivot;
if(low<high)//序列长度大于1

pivot=Quicksort(L,low,high);//将序列一分为二
Quick2(L,low,pivot-1);//对低位子表递归排序
Quick2(L,pivot+1,high);//对高位子表递归排序

return(L);


qSqList Quick(qSqList L)//对顺序表作快速排序

long low,high;
low=1;//将第一个数据所在位置定义为低位
high=L->length;//将最后一个数据所在位置定义为高位
L=Quick2(L,low,high);//对顺序表作快速排序
Print(L);
Print2(L);
return(L);


void TourSort(SqList *L,long n)//锦标赛排序

qSqList Lp;
long i=0,t=1,k=1,w;
while(t<n)//t表示完全二叉树的结点个数

t=(long)pow(2,i);
i++;

t=2*t;
Lp=(qSqList)malloc((sizeof(SqList)));
Lp->length=t-1;
for(i=t-1;i>=t/2;i--)

if(k>n)
Lp->r[i].key=MAXNUM;
else

Lp->r[i]=L->r[k];


shifttimes++;
k++;

i=t-1;
while(i!=1)

Lp->r[i/2]=Min1(Lp->r[i],Lp->r[i-1]);
i-=2;
comparetimes++;
shifttimes++;

for(i=1;i<=n;i++)

L->r[i]=Lp->r[1];
shifttimes++;
w=1;
while(w<t/2)

if(Lp->r[2*w].key==Lp->r[w].key)
w*=2;
else
w=2*w+1;

Lp->r[w].key=MAXNUM;//将其赋为最大值
shifttimes++;
if(w%2)
Lp->r[w/2]=Lp->r[w-1];
else
Lp->r[w/2]=Lp->r[w+1];
shifttimes++;
while(w!=1)

if(w%2)
Lp->r[w/2]=Min1(Lp->r[w],Lp->r[w-1]);
else
Lp->r[w/2]=Min1(Lp->r[w],Lp->r[w+1]);
comparetimes++;
shifttimes++;
w/=2;


Print(L);
Print2(L);


void Heapadjust(qSqList L,long s,long m)//调整L->[s]的关键字，使L->r[s..m]成为一个大顶堆

long j;
struct node rc;
rc=L->r[s];
for(j=2*s;j<=m;j*=2)//沿key较大的接点向下筛选

if(j<m&<(L->r[j].key,L->r[j+1].key))//j为key较大的记录的下标

j++;
comparetimes++;

if(!LT(rc.key,L->r[j].key))

comparetimes++;
break;

L->r[s]=L->r[j];//rc插入位置s
shifttimes++;
s=j;

L->r[s]=rc;//插入
shifttimes++;


qSqList Heap(qSqList L)//堆排序

long i;
for(i=L->length/2;i>0;--i)//把L建成大顶堆
Heapadjust(L,i,L->length);
for(i=L->length;i>1;--i)//将堆顶记录和当前未经排序子序列中最后一个记录交换

L->r[0]=L->r[1];
L->r[1]=L->r[i];
L->r[i]=L->r[0];
shifttimes=shifttimes+3;
Heapadjust(L,1,i-1);//将L重新调整为大顶堆

Print(L);
Print2(L);
return(L);


void Merge(qSqList L,int low,int m,int high)//将两个有序表R[low..m]he R[m+1..high]归并为一个有序表R[low,high]

int i=low,j=m+1,k=0;//k是temp的下标，i,j分别为第1，2段的下标
struct node *temp;
temp=(struct node*)malloc((high-low+1)*sizeof(struct node));//用于临时保存有序序列
while(i<=m&&j<=high)//在第1段和第2段均未扫描完时循环

if(LT(L->r[j].key,L->r[i].key))//将第1段中的记录放入temp中

temp[k]=L->r[j];
j++;
k++;

else//将第2段中的记录放入temp中

temp[k]=L->r[i];
k++;
i++;


while(i<=m)//将第1段余下的部分复制到temp

temp[k]=L->r[i];
k++;
i++;

while(j<=high)//将第2段余下的部分复制到temp

temp[k]=L->r[j];
k++;
j++;

for(k=0,i=low;i<=high;i++,k++)//将temp复制回L中

L->r[i]=temp[k];



void MSort(qSqList L,int low,int high)//二路归并排序

int m;
if (low<high)

m=(low+high)/2;
MSort(L,low,m);
MSort(L,m+1,high);
Merge(L,low,m,high);



void Merging(qSqList L)//归并排序

MSort(L,1,L->length);
Print2(L);


void Radixsort(qSqList L)//基数排序

int g,i,j,k,d=2;
struct node2 *p,*s,*t,*head[10],*tail[10];//定义各链队的首尾指针
for(i=1;i<=L->length;i++) //建立链表

s = (struct node2*)malloc(sizeof(struct node2));
s->r.key = L->r[i].key;
s->r.num= L->r[i].num;
if(i==1)

t = s;
p = s;
g++;
else

t->next = s;
t = s;
g++;

t->next = NULL;

d=1;
for(i=1;i<6;i++)

for(j=0;j<10;j++)
head[j] = tail[j] = NULL; //初始化各链队首、尾指针
while(p!=NULL)//对于原链表中的每个结点循环

k = p->r.key/d;
k = k%10;
if(head[k]==NULL)//进行分配

head[k]=p;
tail[k]=p;

else

tail[k]->next=p;
tail[k]=p;

p = p->next;//取下一个待排序的元素

p=NULL;
for(j=0;j<10;j++)//对每一个链队循环

if(head[j]!=NULL)//进行搜集

if(p == NULL)

p = head[j];
t = tail[j];

else

t->next=head[j];
t = tail[j];



t->next=NULL;//最后一个结点的next置为空
d=d*10;

i=1;
while(p!=NULL)

L->r[i] = p->r;
i++;
p=p->next;
Print2(L);


char chmenu()//对排序方法进行选择

char ch;
printf("\n\t请选择排序方法:"
"\n\t*************"
"\n\t1.Shell排序"
"\n\t2.Quick排序"
"\n\t3.锦标赛排序"
"\n\t4.堆排序"
"\n\t5.归并排序"
"\n\t6.基排序"
"\n\t7.结束"
"\n\t*************");
do
printf("\n\tplease choose (1-7):");
getchar();
ch=getchar();
while(!(ch>'0'&&ch<'8'));
return(ch);


void main()

int a=1;
FILE *fp;
char ch,filename[N];
qSqList L;
while(a)

printf("\n\t请输入读入文件名:");//输入要读入的文件名
scanf("%s",filename);
if((fp=fopen(filename,"r"))==NULL)

printf("cannot open the file\n");
exit(0);

L=creat(filename);
while(1)

if((ch=chmenu())=='7')
break;
switch(ch)

case'1':shifttimes=comparetimes=0;shell(L);break;
case'2':shifttimes=comparetimes=0;Quick(L);break;
case'3':shifttimes=comparetimes=0;TourSort(L,L->length);break;
case'4':shifttimes=comparetimes=0;Heap(L);break;
case'5':shifttimes=comparetimes=0;Merging(L);break;
case'6':shifttimes=comparetimes=0;Radixsort(L);break;


printf("\n\t***************"
"\n\t1.继续读入文件"
"\n\t0.结束"
"\n\t***************");
do
printf("\n\tplease choose (0-1):");
getchar();
scanf("%d",&a);
while(!(a==1||a==0));


参考技术A 数据结构算法-排序的各种方法
void shellsort(sqlist l,int d)

int i,j;
d=l.length/2;
while(d>0)

for(i=d 1;i<=l.length; i)
if(l.r[i].key<l.r[i-d].key)

l.r[0]=l.r[i];
for(j=i-d;j>0&&l.r[0].key<l.r[j].key;j-=d)
l.r[j d]=l.r[j];
l.r[j d]=l.r[0];
d=d/2;

;
;
;
void quicksort(sqlist l,int low,int high)
int i,j;
if(low<high)
i=low;j=high;l.r[0]=l.r[i];
do

while(i<j&&l.r[j].key>l.r[0].key)
--j;
if(i<j)
l.r[i]=l.r[j]; i;
while(i<j&&l.r[i].key<=l.r[0].key)
i;
if(i<j)
l.r[j]=l.r[i];--j;

while(i!=j);
l.r[i]=l.r[0];
quicksort(l,low,i-1);
quicksort(l,i 1,high);


;
;
;
void heapadjust(sqlist l,int s,int m)

int rc,j;
rc=l.r[s].key;
for(j=2*s;j<=m;j*=2)

if(j<m&&l.r[j].key<l.r[j 1].key)
j ;
if(rc>l.r[j].key)
break;
l.r[s].key=l.r[j].key;
s=j;

l.r[s].key=rc;

;
;
;
void heapsort(sqlist l)

int i,t;
for(i=l.length/2;i>0;i--)
heapadjust(l,i,l.length);
for(i=l.length;i>1;i--)

t=l.r[1].key,l.r[1].key=l.r[i].key,l.r[i].key=t;
heapadjust(l,1,i-1);


;
;
;
void oesort(sqlist l,int n)

int t,i,change;
change=1;
while(change)

change=0;
for(i=1;i<n;i =2)
if(l.r[i].key>l.r[i 1].key)

t=l.r[i].key,l.r[i].key=l.r[i 1].key,l.r[i 1].key=t;
change=1;

for(i=2;i<n;i =2)
if(l.r[i].key>l.r[i 1].key)

t=l.r[i].key,l.r[i].key=l.r[i 1].key,l.r[i 1].key=t;
change=1;



;
;
;
main()

int i,j,low,high,a[maxsize 1];
char ch;
sqlist l;
clrscr();
l.r=(redtype *)malloc(maxsize*sizeof(int));
if(!l.r)
printf("overflow");
l.length=0;
printf("\n\nplease input five elements:\n\n");
for(i=1;i<maxsize 1;i )

scanf("%d",&a[i]);
l.length ;

getchar();
do

for(j=1,i=1;j<maxsize 1;i ,j )
l.r[i].key=a[j];
printf("\n\nWelcome to use PanWeiFeng's KeChenSheJi\n\n");
printf("s:shellsort\tq:quicksort\n\n");
printf("h:heapsort\te:oesort\n\n");
printf("o:quit\n\n");
printf("please input the way:");
ch=getchar();
clrscr();
printf("\n\nthe orignal array:");
for(i=1;i<maxsize 1;i )
printf("%d ",l.r[i].key);
printf("\n\n");
/*printf("please input the way:");
ch=getchar();*/
getchar();
switch(ch)

case 's':
shellsort(l,l.length);
printf("\n\nthe odered arry:");
for(i=1;i<maxsize 1;i )
printf("%d ",l.r[i].key);
printf("\n\n");
break;
case 'q':
low=1;high=l.length;
quicksort(l,low,high);
printf("\n\nthe odered arry:");
for(i=1;i<maxsize 1;i )
printf("%d ",l.r[i].key);
printf("\n\n");
break;
case 'h':
heapsort(l);
printf("\n\nthe odered arry:");
for(i=1;i<maxsize 1;i )
printf("%d ",l.r[i].key);
printf("\n\n");
break;
case 'e':
oesort(l,l.length);
printf("\n\nthe odered arry:");
for(i=1;i<maxsize 1;i )
printf("%d ",l.r[i].key);
printf("\n\n");
break;
case 'o':
exit(0);
default:
printf("\n\nerror!write again!\n");

while(1);


数据结构里的各种排序方法及其效率分析
在visual c++6.0里面编译 你自己看
#include "stdafx.h"
#define MAXSIZE 50
#include <stdio.h>
typedef struct

int key;
RECNODE;

int b,t;
int MakeList(RECNODE *r)

int j,k;
printf("\n请输入初始数据(每个数据以空格隔开，-1结束）： ");
k=0;
scanf("%d",&j);
while(j!=-1)

k++;
r[k].key=j;
scanf("%d",&j);

return k;


void UndealoutList(RECNODE *r,int n)

int i;
printf("\n未排序前的数据 ： ");
for(i=0;i<n;i++)
printf(" %d",r[i+1].key);
printf("\n\n");


void DealoutList(RECNODE*r,int n)

int i;

printf("排序后的数据 ： ");
for(i=0;i<n;i++)
printf(" %d",r[i+1].key);
printf("\n\n");
printf("交换或比较的次数： %d\n",b);
printf("排序的趟数： %d\n",t);


void InsertSort(RECNODE*r,int n)//直接插入排序//

int i,j;
b=0,t=0;

for(i=2;i<=n;i++)

r[0]=r[i];
j=i-1;
while(r[0].key<r[j].key)

r[j+1]=r[j];
j--;
b++;

r[j+1]=r[0];
b++;
t++;




void BubleSort(RECNODE *r,int n) //冒泡排序//

int i,j;
b=0,t=0;
RECNODE temp;
for(i=1;i<n;i++)

for(j=n-1;j>=i;j--)
if(r[j+1].key<r[j].key)

temp=r[j+1];
r[j+1]=r[j];
r[j]=temp;
b++;

else b++;
t++;




int Partition(RECNODE*r,int*low,int*high)//一躺快速排序//

int i,j;
static int w=0;
RECNODE temp;
i=*low;
j=*high;
temp=r[i];
do

while((r[j].key>=temp.key)&&(i<j))

j--;
w++;

if(i<j)

r[i]=r[j];
i++;
w++;

while((r[i].key<=temp.key)&&(i<j))

i++;
w++;

if(i<j)

r[j]=r[i];
j--;
w++;

while(i!=j);
r[i]=temp;
b=w;
return i;


void QuickSort(RECNODE*r,int start,int end)//快速排序//

int i;
static int q=0;
if(start<end)

i= Partition(r,&start,&end);
q++;
QuickSort(r,start,i-1);
QuickSort(r,i+1,end);

t=q;


void SeleSort(RECNODE*r,int n)//直接选择排序//

int i,j,z;
b=0,t=0;
RECNODE temp;
for(i=1;i<n;i++)

z=i;
for(j=i+1;j<=n;j++)
if(r[j].key<r[z].key)

z=j;
b++;

else b++;
if(z!=i)

temp=r[i];
r[i]=r[z];
r[z]=temp;

t++;




void ShellSort(RECNODE *r,int n)//希尔排序//

int i,j,dk;
b=0,t=0;
dk=n/2;
while(dk>0)

for(i=dk+1;i<n;++i)
if(r[i].key<r[i-dk].key)

r[0]=r[i];
for(j=i-dk;j>0&&r[0].key<r[j].key;j-=dk)

r[j+dk]=r[j];
b++;

r[j+dk]=r[0];

dk=dk/2;
t++;




void Sift(RECNODE*r,int i,int m)

int j;
static int x=0;
RECNODE temp;
temp=r[i];
j=2*i;
while(j<=m)

if(j<m&&(r[j].key<r[j+1].key))

j++;
x++;

if(temp.key<r[j].key)

r[i]=r[j];
i=j;
j=2*i;
x++;

else x++; break;

r[i]=temp;
b=x;


void HeapSort(RECNODE*r,int n)//堆排序//

RECNODE temp;
int i;
t=0;
for(i=n/2;i>=1;i--)
Sift(r,i,n);
for(i=n;i>=2;i--)

temp=r[1];
r[1]=r[i];
r[i]=temp;
Sift(r,1,i-1);
t++;




void main()

RECNODE a[MAXSIZE];
int len,p;
do

printf("**********************\n");
printf("* 菜 单 *\n");
printf("**********************\n");
printf("* 1---直接插入排序 *\n");
printf("* 2---冒泡排序 *\n");
printf("* 3---快速排序 *\n");
printf("* 4---直接选择排序 *\n");
printf("* 5---堆排序 *\n");
printf("* 6---希尔排序 *\n");
printf("* 0---退出 *\n");
printf("**********************\n");
printf("\n请在上述序号中选择一个并输入： ");
scanf("%d",&p);
switch(p)

case 1:len=MakeList(a);
UndealoutList(a,len);
InsertSort(a,len);
DealoutList(a,len);
break;
case 2:len=MakeList(a);
UndealoutList(a,len);
BubleSort(a,len);
DealoutList(a,len);
break;
case 3:len=MakeList(a);
UndealoutList(a,len);
QuickSort(a,1,len);
DealoutList(a,len);
break;
case 4:len=MakeList(a);
UndealoutList(a,len);
SeleSort(a,len);
DealoutList(a,len);
break;
case 5:len=MakeList(a);
UndealoutList(a,len);
HeapSort(a,len);
DealoutList(a,len);
break;
case 6:len=MakeList(a);
UndealoutList(a,len);
ShellSort(a,len);
DealoutList(a,len);
break;
case 0:break;
default:printf("输入错误！请重新输入!\n");break;

while(p!=0);

参考技术B 数据结构中的排序算法,各有用处,比如:
1,直接插入排序,在序列基本有序的情况下,移动的次数比较少,但是比较次数是一样的
复杂度O(n*n);
2,冒泡排序,这个不用说了吧,刚学C的人都懂了
3,希尔排序,只要是找出较好的增量,将数据排列成基本有序时,最后一次来一次直接插入排序,是对直接插入排序的改进.复杂度为O(n(3/2));
4,快速排序,算是所有排序中复杂度一般情况下比较好的算法,它设了一个枢轴,将它分为两部分,左边比它小,右边的比它大,复杂度为O(nlog n);
5,选择排序,和冒泡差不多的复杂度,
6,归并排序,这是一种稳定的排序方法,将数据分为各个有序的部分,再组合为一个整体,只要用递归的方法.
7,还有基数排序,树形排序,堆排序,等等,这里不多说了,你多多学习多多消化吧,慢慢学吧,多看看课本的算法,自己实现一次,学完了你的编程能力就能很好的提高了. 参考技术C 看《数据结构》，你一定会搞懂的本回答被提问者采纳 参考技术D 这个要讲得当面讲才有点效果。在网上想学好比较难。我希望你回去认真看点书。比在这儿浪费积分强得多。