对以下6种常用的内部排序算法进行比较：起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序。

题目要求：

（1）对以下6种常用的内部排序算法进行比较：起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序。
（2）待排序表的表长不小于100；其中的数据要用伪随机数产生程序产生；至少要用5组不同的输入数据作比较；比较的指标为有关键字参加的比较次数和关键字的移动次数（关键字交换计为3次移动）。
（3）最后要对结果作出简单分析，包括对各组数据得出结果波动大小的解释。
（4）希尔排序：先将整个待排记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序。
（5）直接插入排序：将一个记录插入到已排序好的有序表中，从而得到一个新的、记录数增1的有序表。设整个排序有n个数，则进行n-1趟插入，即：先将序列中的第1个记录
看成是一个有序的子序列，然后从第2个记录起逐个进行插入，直至整个序列变成按关键字非递减有序列为止。
（6）显示各排序算法排序后的的数据和时间效率，并比较找出其中2种较快的方法。

流程图：

设计：

1.冒泡排序：
冒泡排序的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。
2.直接插入排序：
直接插入排序是一种最简单的排序方法，它的基本操作是将一个记录插入到已牌号序的有序表中，从而得到一个新的、记录数增1的有序表。
3.简单选择排序：
在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环。
4.希尔排序：
希尔排序又称“缩小增量排序”，它也是一种属插入排序类的方法，但在时间效率上较前述集中排序方法有较大的改进。它的基本思想是：先将整个待排序记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序。
5.堆排序：
由二叉堆的定义可知，堆顶元素（即二叉堆的根节点）一定为堆中的最大值或最小值，因此如果我们输出堆顶元素后，将剩余的元素再调整为二叉堆，继而再次输出堆顶元素，再将剩余的元素调整为二叉堆，反复执行该过程，这样便可输出一个有序序列，这个过程我们就叫做堆排序。
6.归并排序：
归并的含义很明显就是将两个或者两个以上的有序表组合成一个新的有序表。归并排序中一般所用到的是2-路归并排序，即将含有n个元素的序列看成是n个有序的子序列，每个子序列的长度为1，而后两两合并，得到n/2个长度为2或1的有序子序列，再进行两两合并。。。直到最后由两个有序的子序列合并成为一个长度为n的有序序列。2-路归并的核心操作是将一维数组中前后相邻的两个有序序列归并为一个有序序列。
7.快速排序：
快速排序的基本实现思想就是将当前待排序列分成两个部分、一个值。一个值：就是选定出一个值作为被比较的元素。两个部分：所有比该被选定元素大的部分都去该元素的右边，所有比被选定元素小的部分都去该元素的左边。这样我们就确定了该元素在这个待排序列中的位置，其实也就是我们已经将这个元素“排好了”。

代码：

#include
#include
#include
#include
#include
#define N 100
int p,q;
//起泡排序
void gensort(int b[],int n)
{
int i,j;int s=0,t=0;
for(i=0;i {
for(j=i+1;j {
t++;
if(b[i]>b[j])
{
int temp=b[i];
b[i]=b[j];
b[j]=temp;
s+=3;
}}}
cout<<“移动次数=”< }
//插入排序
typedef int KeyType;
struct rec
{
KeyType key;
};
typedef rec sqlist[N];
void insertsort(sqlist b,int n)
{
int i,j;int s=0,t=0;
for(i=2;i {
b[0]=b[i];
s++;
j=i-1;
t++;
while(b[0].key {
b[j+1]=b[j];
j–;
s++;
t++;
}
b[j+1]=b[0];
s++;
}
cout<<“移动次数=”< }
//希尔排序
void shellsort(sqlist b,int n)
{
int i,j,gap;
rec x;
int s=0,t=0;
gap=n/2;
while(gap>0)
{
for(i=gap+1;i {
j=i-gap;
while(j>0)
{
t++;
if(b[j].key>b[j+gap].key)
{
x=b[j];b[j]=b[j+gap];
b[j+gap]=x;j=j-gap;
s+=3;
}
else j=0;
gap=gap/2;
}}
cout<<“移动次数=”< }}
//选择排序
void gentsort(int b[],int n)
{
int i,j,k;
int s=0,t=0;
for(i=0;i {
k=i;
for(j=i+1;j {
t++;
if(b[k]>b[j])
{k=j;}
}
if(k!=i)
{int temp=b[k];
b[k]=b[i];
b[i]=temp;
s+=3;
}}
cout<<“移动次数=”< }
//快速排序
void output(sqlist b,int n)//输出元素值
{
for(int i=0;i cout< cout< }
void display(int n,int m)//输出计数
{
cout<<“移动次数=”< }
void BeforeSort()//初始化计数器
{
p=0;q=0;
}
void quicksort(sqlist r,int s,int t)
{
int i=s,j=t;
if(s {
r[0]=r[s];p++;
while(i {
p++;
while(i=r[0].key)
j–;
r[i]=r[j];
q++;
p++;
p++;
while(i i++;
r[j]=r[i];q++;p++;
}
r[i]=r[0];p++;
}
else return;
quicksort(r,s,j-1);
quicksort(r,j+1,t);
}
void sort(sqlist r,int s,int t)
{
BeforeSort();
quicksort(r,s,t);
display(p,q);
}
//堆排序
void sift(sqlist r,int s,int m)
{
int j;
rec x;
x=r[s];
for(j=2s;j<=m;j=2)
{q++;
if(j ++j;
q++;
if(!(x.key r[s]=r[j];s=j;p++;}
r[s]=x;p++;
}
void heapsort(sqlist &r,int m)
{
int i;rec w;
for(i=m/2;i>0;–i)
sift(r,i,m);
for(i=m;i>1;–i)
{
w=r[i];r[i]=r[1];
r[1]=w;
p+=3;
sift(r,1,i-1);
}
}
void sorting(sqlist &r,int t)
{
BeforeSort();
heapsort(r,t);
display(p,q);
}
void init(int a[]){//随机生成N个整数并
int i;
srand ( ( unsigned int ) time ( NULL ) );
for(i=0;i a[i]=rand()%99+1;
}
void main()
{
int a1[N],i;
int e=N;
sqlist a,b,c,d;
int c1[N];
int low=0,high=10;
init(a1);
for(i=0;i {
c1[i]=a1[i];
a[i].key=a1[i];
b[i].key=a1[i];
c[i].key=a1[i];
d[i].key=a1[i];
}
cout<<“排序前数组:\n”;
for(i=0;i cout< cout< cout<<“起泡排序运行结果:\n”;
gensort(a1,sizeof(a1)/sizeof(int));
cout<<“插入排序运行结果:\n”;
insertsort(a,N);
cout<<“希尔排序运行结果:\n”;
shellsort(b,N);
cout<<“选择排序运行结果:\n”;
gentsort(c1,N);
cout<<“快速排序运行结果:\n”;
sort(c,low,high);
cout<<“堆排序运行结果:\n”;
sorting(d,N);
cout<<“排序后数组:\n”;
for(i=0;i cout< cout< }

程序员初成长路线:(很全面的学习视频，网址…点击查看)https://blog.csdn.net/qq_43541242/article/details/107165068