数据结构各种排序

插入排序 178 717 1628 2882 4458 6446 8822 11649 14547 17914
自底向上归并排序 3 6 9 12 15 18 22 26 28 33
自顶向下归并排序 3 7 11 15 18 23 27 31 36 40
快速排序 2 5 8 11 14 18 21 25 29 32
}//所以下面一直可以输出前的排序格式
printf("待排序的数据为：\n");
for(x=1;x<=howmany;x++)
{
printf("%d ",olddata[x]);
}
printf("\n");
}
int outnew0()/ቤተ መጻሕፍቲ ባይዱ排序后数据输出 从大到小
{
t=i;
for(j=i+1;j<howmany;j++)
{
if(datanum[j]<datanum[i]) t=j;
if(i!=t)
{
temp=datanum[t];
datanum[t]=datanum[i];
datanum[i]=temp;
堆排序利用了大根堆(或小根堆)堆顶记录的关键字最大(或最小)这一特征，使得在当前无序区中选取最大(或最小)关键字的记录变得简单
#include<iostream>
using namespace std;
int main()
{
//srand((unsigned)time(NULL));
希尔排序：将无序数组分割为若干个子序列，子序列不是逐段分割的，而是相隔特定的增量的子序列，对各个子序列进行插入排序；然后再选择一个更小的增量，再将数组分割为多个子序列进行排序......最后选择增量为1，即使用直接插入排序，使最终数组成为有序。
增量的选择：在每趟的排序过程都有一个增量，至少满足一个规则 增量关系 d[1] > d[2] > d[3] >..> d[t] = 1 (t趟排序)；根据增量序列的选取其时间复杂度也会有变化，这个不少论文进行了研究，在此处就不再深究；本文采用首选增量为n/2,以此递推，每次增量为原先的1/2，直到增量为1；
{
int i,j;
printf("排序后的结果为:\n");
for(i=howmany;i>=1;i--)
{
printf("%d ",datanum[i]);
}
printf("\n\n");
}
int outnew1()//排序后逆序数据输出 从小到大
{
int i,j;
}
datanum[j]=temp;
}
if(!t)
outnew0();//输出排序后顺序
else
outnew1();
}
void maopao()//冒泡排序
{
int i,j;
int temp;
output_num();
for(i=1;i<=howmany-1;i++)
{
max=lchild;
}
if(rchild<=size&&a[rchild]>a[max])
{
max=rchild;
}
if(max!=i)
{
for(j=1;j<=howmany-i-1;j++)
{
if(datanum[j]>datanum[j+1])
{
temp=datanum[j];
datanum[j]=datanum[j+1];
datanum[j+1]=temp;
}
//for(int i=0;i<size;i++)
// printf("%d ",b[i]);
//for(int i=size-1;i>=0;i--)
}
}
if(!t)
outnew0();//输出排序后顺序
else
outnew1();
}
void xuanze()//选择排序
{
int i,j;
int temp,t;
output_num();
for(i=1;i<=howmany-1;i++)
{
int i;
for(i=size/2;i>=1;i--) //非叶节点最大序号值为size/2
{
HeapAdjust(a,i,size);
}
}
void HeapSort(int *a,int size) //堆排序
{
int j=1;
}
}
}
if(t)
outnew0();//输出排序后顺序
else
outnew1();
}
//堆操作起点
void HeapAdjust(int *a,int i,int size) //调整堆
{
int lchild=2*i; //i的左孩子节点序号
old[i]=datanum[i]; //old为用户输入数据
}
}
int output_num()//排序前数据输出
{
int olddata[100];//这是用来存放排序前的数的
int x;
for(x=1;x<=howmany;x++)
{
olddata[x]=old[x];//把old中的数据传过去，因为old中的数据没改变过，
{
int i,j;
int temp;
output_num();//显示用户输入数据的顺序
for(i=1;i<=howmany;i++)
{
int temp=datanum[i];
for (j=i;j>0 && temp<datanum[j-1];j--)
{
datanum[j]=datanum[j-1];
堆排序 O(nlog2n) O(1) 否
基数排序 O(dn) O(rn) 是
希尔排序 \ O(1) 否
排序的时间效率比较
下图表名了各种算法在不同数据规模下，完成排序所消耗的时间（毫秒为单位），从表中可以显然看出O(n2)的排序算法比O(nlog2n)的算法 时间多出几百上千倍，而且随着数据数据规模增大时间比也会随着增大；因为排序的数据采用随机数，顺序将被打乱，快速排序算法优于其他排序算法！
srand(NULL);
for(int i=1;i<=100;i++)
{
int t=rand()%10000;
cout<<t<<" ";
if(i%10==0)
cout << endl;
}
return 0;
}
#include<cstdio>
#include<algorithm>
算法名称 1万 2万 3万 4万 5万 6万 7万 8万 9万 10万
冒泡排序 1442 5497 12206 21861 34017 49148 67394 88880 111939 139071
选择排序 199 816 1790 3254 5062 7166 9645 12636 16102 19643
堆排序 3 7 12 16 19 23 26 30 34 37
基数排序 9 21 30 40 49 59 66 75 90 98
希尔排序 3 8 11 15 24 24 29 35 40 41
下面采用图表形式将数据直观展示出来(将O(n2)的算法和O(nlog2n)算法分开，因为完全不是一个数量级的):
using namespace std;
const int N=100010;
int howmany,datanum[N]; //全局变量定义数组和用户输入个数
int old[N],a[N],t;
//全局变量定义一个数组用于接受用户输入并保持其不变
int input_num()//数据输入
#include<iostream>
#include<cmath>
#include<cstring>
#include<string>
#include<stack>
#include<map>
#include<queue>
#include<vector>
#include<set>
#include<cstdlib>
{
swap(a[i],a[max]);
HeapAdjust(a,max,size); //避免调整之后以max为父节点的子树不是堆
}
}
}
void BuildHeap(int *a,int size) //建立堆
int rchild=2*i+1; //i的右孩子节点序号
int max=i; //临时变量
if(i<=size/2) //如果i是叶节点就不用进行调整