常用排序算法比较

最新推荐文章于 2022-11-04 08:09:15 发布

轩辕_x

最新推荐文章于 2022-11-04 08:09:15 发布

阅读量340

点赞数

1.稳定性比较

插入排序、冒泡排序、二叉树排序、二路归并排序及其他线形排序是稳定的

选择排序、希尔排序、快速排序、堆排序是不稳定的

2.时间复杂性比较

插入排序、冒泡排序、选择排序的时间复杂性为O(n2)

其它非线形排序的时间复杂性为O(nlog2n)

线形排序的时间复杂性为O(n);

3.辅助空间的比较

线形排序、二路归并排序的辅助空间为O(n),其它排序的辅助空间为O(1);

4.其它比较

插入、冒泡排序的速度较慢，但参加排序的序列局部或整体有序时，这种排序能达到较快的速度。

反而在这种情况下，快速排序反而慢了。

当n较小时，对稳定性不作要求时宜用选择排序，对稳定性有要求时宜用插入或冒泡排序。

若待排序的记录的关键字在一个明显有限范围内时,且空间允许是用桶排序。

当n较大时，关键字元素比较随机，对稳定性没要求宜用快速排序。

当n较大时，关键字元素可能出现本身是有序的，对稳定性有要求时，空间允许的情况下。

宜用归并排序。

当n较大时，关键字元素可能出现本身是有序的，对稳定性没有要求时宜用堆排序。

5、算法思想简述：

（1）冒泡排序：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。冒泡排序是稳定的。算法时间复杂度O(n2)。

（2）选择排序：在要排序的一组数中，选出最小的一个数与第一个位置的数交换，然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。选择排序是不稳定的。算法复杂度O(n2)。

（3）插入排序：在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。直接插入排序是稳定的。算法时间复杂度O(n2)。

（4）希尔排序：算法先将要排序的一组数按某个增量d分成若干组，每组中记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量对它进行，在每组中再进行排序。当增量减到1时，整个要排序的数被分成一组，排序完成。希尔排序是不稳定的。

（5）快速排序：快速排序是对冒泡排序的一种本质改进。它的基本思想是通过一趟扫描后，使得排序序列的长度能大幅度地减少。在冒泡排序中，一次扫描只能确保最大数值的数移到正确位置，而待排序序列的长度可能只减少1。快速排序通过一趟扫描，就能确保某个数（以它为基准点吧）的左边各数都比它小，右边各数都比它大。然后又用同样的方法处理它左右两边的数，直到基准点的左右只有一个元素为止。

下面贴代码：

#include "stdafx.h"
#include <stdio.h>
int data1[]={25, 18, 12 ,10, 2 };
int data2[]={34,32,20,16,6};
int data3[10];
int data[10]={75,23,98,44,57,12,29,64,38,82};
void bubleSort(int data[] , int size);
void select_sort(int data[] , int size);
void insertion_sort(int data[] , int size);
void merge_sort(int data1[],int size1,int data2[],int size2,int data3[]);
void quick_sort(int data[] ,int left ,int right,int size);
void deleteMax(int data[] , int size);
void percolateDown(int data[],int target ,int size);
void buildMaxHeap(int data[] , int size);
void heapSort(int data[], int size);
void shell_Sort(int data[],int size);
void shell_Sort(int data[],int size);
int main(int argc, char* argv[])
{
// bubleSort(data ,5);
// select_sort(data ,5);
// insertion_sort(data,5);
// merge_sort(data1,5,data2,5,data3);
// quick_sort( data1 ,0 ,4,5);
// heapSort(data1,5);
// shell_Sort(data,11);
return 0;
}
//冒泡排序
void bubleSort(int data[] , int size)
{
int i,j,k;
int temp;
int flag=0;
printf("buble Sorting Proceddure/n");
for (i=0;i<size-1;i++)
{
flag =0;
for (j=0;j<size-i-1;j++)
{
if (data[j] > data[j+1])
{
flag = 1;
temp = data[j];
data[j] = data[j+1];
data[j+1] = temp;
}
}
printf("Sorting %d times: ",i+1);
for(k=0;k<size;k++)
printf("%d ",data[k]);
printf("/n");
if(!flag)break;
}
printf("_______________________________/n");
}
//选择排序
void select_sort(int data[] , int size)
{
int i,j,k;
int temp,pos;
printf("Select Sorting Proceddure/n");
for (i=0;i<size-1;i++)
{
pos = i;
for(j=i+1;j<size;j++)
{
if(data[j] < data[pos])
pos = j;
}
temp =data[i];
data[i] = data[pos];
data[pos] = temp;
printf("Sorting %d times: ",i+1);
for(k=0;k<size;k++)
printf("%d ",data[k]);
printf("/n");
}
printf("_______________________________/n");
}
//插入排序
void insertion_sort(int data[] , int size)
{
int i,k;
int temp,pos;
printf("Insertion Sorting Proceddure/n");
for (i=1;i<size;i++)
{
temp = data[i];
pos = i;
while (pos>0 && data[pos-1]>temp)
{
data[pos] = data[pos-1];
pos--;
}
data[pos] = temp;
printf("Sorting %d times: ",i);
for(k=0;k<size;k++)
printf("%d ",data[k]);
printf("/n");
}
printf("_______________________________/n");
}
//归并排序
void merge_sort(int data1[],int size1,int data2[],int size2,int data3[])
{
int arg1=0,arg2=0;
int arg3,i;
printf("Merge Sorting Proceddure/n");
select_sort(data1,size1);
select_sort(data2,size2);
for(arg3=0;arg3<size1+size2&&arg1<size1&&arg2<size2;arg3++)
{
if (data1[arg1]<data2[arg2])
{
data3[arg3] = data1[arg1];
arg1++;
}
else if (data1[arg1]>data2[arg2])
{
data3[arg3]= data2[arg2];
arg2++;
}
else
{
data3[arg3] = data1[arg1];
arg1++;
arg2++;
}
}
while (arg1<size1)
{
data3[arg3++]=data1[arg1++];
}
while (arg2<size2)
{
data3[arg3++]=data2[arg2++];
}
printf("Merge sort: ");
for (i=0;i<size1+size2;i++)
printf("%d ",data3[i]);
printf("/n");
printf("___________________________________________________________/n");
}
//快速排序
void quick_sort(int data[] ,int left ,int right,int size)
{
int lbase,rbase,temp,i;
lbase = left+1;
rbase = right;
if(left<right)
{
lbase = left+1;
rbase = right;
while (data[lbase] < data[left])
lbase++;
while(data[rbase]>data[left])
rbase--;
while (lbase<rbase)
{
temp = data[lbase];
data[lbase] = data[rbase];
data[rbase] = temp;
lbase++;
rbase--;
while (data[lbase] < data[left])
lbase++;
while(data[rbase]>data[left])
rbase--;
}
temp = data[left];
data[left] = data[rbase];
data[rbase] = temp;
for (i=0;i<size;i++)
printf("%d ",data[i]);
printf("/n");
quick_sort(data,left,rbase-1,size);
quick_sort(data,rbase+1,right,size);
}
}
/**********************堆排序begin*************************/
//改造大根堆
void buildMaxHeap(int data[] , int size)
{
int i;
for (i=size/2-1;i>=0;i--)
{
percolateDown(data,i,size);
}
}
//删除最大值
void deleteMax(int data[] , int size)
{
int tmp;
tmp = data[0];
data[0] =data[size-1];
data[size-1] = tmp;
percolateDown(data, 0, --size);
}
//下滤
void percolateDown(int data[],int target ,int size)
{
int child=0;
int temp=data[target];
for (; (target*2+1)<=(size-1); target=child)
{
child = target*2 + 1;
if (child<size-1 && (data[child+1] > data[child]))
child++;
if (data[child]>temp)
data[target] = data[child];
else
break;
}
data[target] = temp;
}
void heapSort(int data[], int size)
{
int j;
buildMaxHeap(data, size);
for (int i=size; i>=1; i--)
{
deleteMax(data, i);
for (j=0;j<size;j++)
printf("%d ",data[j]);
printf("/n");
}
}
//希尔排序
void shell_Sort(int data[],int size)
{
int step,i,j,temp,k;
step=size/2;
while (step>0)
{
for (i=step+1;i<size;i++)
{
j=i-step;
while (j>0)
{
if (data[j] > data[j+step])
{
temp = data[j];
data[j] = data[j+step];
data[j+step] = temp;
j-=step;
}
else j=0;
}
}
for (k=0;k<size;k++)
printf("%d ",data[k]);
printf("/n");
step/=2;
}
printf("sorting result : ");
for (k=0;k<size;k++)
printf("%d ",data[k]);
}

轩辕_x

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
常用排序算法比较

1.稳定性比较插入排序、冒泡排序、二叉树排序、二路归并排序及其他线形排序是稳定的选择排序、希尔排序、快速排序、堆排序是不稳定的2.时间复杂性比较插入排序、冒泡排序、选择排序的时间复杂性为O(n2) 其它非线形排序的时间复杂性为O(nlog2n) 线形排序的时间复杂性为O(n);3.辅助空间的比较线形排序、二路归并排序的辅助空间为O(n),其它排序的辅助空间为
复制链接

扫一扫