问答文章1 问答文章501 问答文章1001 问答文章1501 问答文章2001 问答文章2501 问答文章3001 问答文章3501 问答文章4001 问答文章4501 问答文章5001 问答文章5501 问答文章6001 问答文章6501 问答文章7001 问答文章7501 问答文章8001 问答文章8501 问答文章9001 问答文章9501

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

发布网友 发布时间:2022-04-25 19:02

我来回答

10个回答

热心网友 时间:2022-04-06 12:52

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

}
}

热心网友 时间:2022-04-06 14:10

数据结构算法-排序的各种方法
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);

}

热心网友 时间:2022-04-06 15:45

数据结构中的排序算法,各有用处,比如:
1,直接插入排序,在序列基本有序的情况下,移动的次数比较少,但是比较次数是一样的
复杂度O(n*n);
2,冒泡排序,这个不用说了吧,刚学C的人都懂了
3,希尔排序,只要是找出较好的增量,将数据排列成基本有序时,最后一次来一次直接插入排序,是对直接插入排序的改进.复杂度为O(n(3/2));
4,快速排序,算是所有排序中复杂度一般情况下比较好的算法,它设了一个枢轴,将它分为两部分,左边比它小,右边的比它大,复杂度为O(nlog n);
5,选择排序,和冒泡差不多的复杂度,
6,归并排序,这是一种稳定的排序方法,将数据分为各个有序的部分,再组合为一个整体,只要用递归的方法.
7,还有基数排序,树形排序,堆排序,等等,这里不多说了,你多多学习多多消化吧,慢慢学吧,多看看课本的算法,自己实现一次,学完了你的编程能力就能很好的提高了.

热心网友 时间:2022-04-06 17:36

看《数据结构》,你一定会搞懂的

热心网友 时间:2022-04-06 19:44

这个要讲得当面讲才有点效果。在网上想学好比较难。我希望你回去认真看点书。比在这儿浪费积分强得多。

热心网友 时间:2022-04-06 22:09

正经的说,找本数据结构的书看看,挺简单的。

热心网友 时间:2022-04-07 00:50

我教你啊

热心网友 时间:2022-04-07 03:48

用的最多的就是冒泡法吧。

热心网友 时间:2022-04-07 07:03

取下些教程吧

http://video.gougou.com/search?s=%e6%8e%92%e5%ba%8f&id=10000000

热心网友 时间:2022-04-07 10:34

给个邮箱吧 我发给你
数据结构-十大排序算法

以下是关于数据结构中的十大排序算法的详细介绍:1. 插入排序直接插入排序:简单易懂,通过逐个元素插入已排序序列。C 代码示例...折半插入排序:改进版,利用二分查找法提高效率。C 代码示例...2. 希尔排序希尔排序:基于插入排序,通过逐步减小间隔实现高效排序。C 代码示例...3. 交换排序冒泡排序:...

数据结构排序的方法

数据结构主要的内排序方法有冒泡排序,选择排序,插入排序,快速排序,归并排序。按照排序过程设计的存储器的不同分为内部排序与外部排序。内部排序完全在内存中进行,适合数据量不太大的数据元素的排序。外部排序需要访问外部存储器,待排序的数据元素非常多,以至于它们必须存储在外部存储器上。如果对任意一...

数据结构的排序方法有哪些?

1、堆排序(Heapsort)是指利用堆积树(堆)这种数据结构所设计的一种排序算法,它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆,是完全二叉树。2、数据结构与算法,其实这个属于算法的内容。主要的内排序方法有:冒泡排序,选择排序,插入排序,快速排序,归并排序。

数据结构中常见的排序方式都有哪些?比如冒泡排序,快速排序等。每种...

2.希尔排序:由于有时候数据量大,用直接插入就不太合适。于是把你的一组待排序数据按如8、4、2、1的一组增量数来分组,即第一次,a1和a9和a17甚至还有更多间隔为八的数分为一组进行直接插入排序,第二次则是新的a1和a5、a9、a13……依次知道最后比较数据之间的间隔数为1,每次都进行插入排序 3...

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

Print(num);//输出完成排序后的有序数列 }二、 详细设计:重要函数中的算法设计,实现流程,传递参数的说明; 三、调试分析与心得体会: 合并排序是排序的一种常用方法,其主要思想为:将一个无序数列依次分割直到其每个序列只有一个元素为止,然后再将两个序列合并为一个有序数列,依此类推。3.我的数据结构实验课题(...

数据结构中排序和查找各种时间复杂度

数据结构中排序和查找各种时间复杂度 (1)冒泡排序 冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较,交换也发生在这两个元素之间。所以相同元素的前后顺序并没有改变,所以冒泡排序是一种稳定排序算法。(2)选择排序 选择排序是给每个位置选择当前元素最小的,比如给第一个...

数据结构(八)排序

算法时间复杂度为O(n 2 )算法时间复杂度为O(n 2 ),空间复杂度O(递归层数)但平均时间复杂度O(nlog 2 n)选择排序:每一趟在待排元素中选取关键字最小的元素加入有序子序列 算法时间复杂度为O(n 2 )n个关键字序列 称为堆 思路:把所有⾮终端结点都检查⼀遍,是否满⾜...

大学数据结构与算法常用排序算法

数据结构常用算法排序算法 写在前面 排序本质上就是按照某种顺序将一组数排好,分多次重复进行,每次只负责把一个数字放到合适的位置上 两种思路:①先确定一个数字,然后根据数据找合适的位置;②先确定一个位置,根据位置找合适的数字;冒泡排序算法 先确定位置,选最前面或者最后面,假设选择了最后面...

数据结构 堆排序

答案是B 由46,79,56,38,40,84 构造初始结构:46 79 56 36 40 84 从最后一个非叶子结点开始,依次调整:46 79 84 36 40 56 84 79 46 36 40 56 84 79 56 36 40 46 即84,79,56,38,40,46

数据结构的排序算法中,哪些排序是稳定的,哪些排序是不稳定的?

一、稳定排序算法 1. 冒泡排序 2. 鸡尾酒排序 3. 插入排序 4. 归并排序 5. 基数排序 6. 合并排序 7. 基数排序 8. 二叉排序树排序 二、不稳定排序算法 1. 选择排序 2. 希尔排序 3. 快速排序 4. 堆排序 5. 平滑排序 6. 快速排序排序(Sorting)是计算机程序设计中的一种重要操作,它的...

数据结构各种排序总结 数据结构各种排序比较 数据结构八种排序 数据结构中的排序算法 数据结构排序方法有哪几种 数据结构排序总结 数据结构看谁的教程 数据结构 排序 数据结构排序比较
声明声明:本网页内容为用户发布,旨在传播知识,不代表本网认同其观点,若有侵权等问题请及时与本网联系,我们将在第一时间删除处理。E-MAIL:11247931@qq.com
地暖管间距是多少合适 地暖管距离地面要多深 地暖16管和2管有什么区别 人的正常体温是36.2℃~37.3℃度,高于37.3℃叫发烧,那么低于36.2℃叫什... 鼠标不配对码能用吗? 电容串并联时电容大小的计算口诀 这款量化交易软件QMT怎么这么好用? 电容串联和并联的区别及特性 哪个券商可以提供QMT或者Prade量化交易接口? 现在公务员考试很多要求有学位证书,我只有本科毕业证。如果我考了一个... ...如何使用迅投QMT/miniQMT量化程序化交易平台?券商开户低门槛申请权限... 快速排序求解 为什么快速排序先对长度较短的子序列进行排序 C语言的快速排序法的算法 顺便把变化过程用文字描述一下,简单的数组排... 顺序表的操作 C语言的链表的快速排序问题,答得好我多给分!! 快速排序问题请教 声母顺序表怎么排声母顺序表 顺序表怎么排序 当顺序表的长度固定以后,快速排序在什么情况下所需要的比较次数多?_百度问一问 顺序表的排序算法 将数据放入一数组(顺序表)中,用哪中方法排序效率高? 当顺序表的长度固定以后,快速排序在什么情况下所需要的比较次数多? QQ邮箱怎么改 形容自己动手的成语叫什么 自己动手下一句幽默的 现在怎么修改QQ邮箱啊 自己动手丰衣足食的朋友圈说说 赞美自己动手的句子 为什么说自己动手丰衣足食? 怎么更改qq邮箱 如果对下列顺序表分别做快速排序,所需比较次数最少的是 排序简单问题 数据结构,快速排序法,程序是老师给的,执行的时候出问题(排序结果里有很多858993460)改程序! 已知序列(10,18,4,3,6,12,1,9,8)请用快速排序写出每一趟排序的结果. 数位顺序表怎么做 刚买的华为mate30就出现发热卡机是怎么回事? 面包粉能包饺子吗? 面包粉能包饺子吗 雪兔牌高级面包粉可以包饺子吗? 华为mate30Epro新买的有时速度也慢怎么回事? 全麦面可以包饺子吗 康师傅红烧牛肉面热量是多少? 谁能给我解释一下康师傅红烧牛肉面珍品和康师傅红烧牛肉面有什么区别?一个2.5一个2.00 康师傅红烧牛肉面酱料的配方有哪些 康师傅红烧牛肉面最佳烹饪方法 晚上吃烤鸭好不好啊,是不是会长胖? 晚上吃烤鸭为什么不好? 烤鸭能吃吗? 吃鸭肉好吗 吃鸭肉有什么好处,什么人不能吃?