排序算法比较（几种经典排序算法优劣比较的C++程序实现）

本文目录

• 几种经典排序算法优劣比较的C++程序实现
• 数据结构中几种常见的排序算法之比较
• 各种排序算法最好和最坏情况比较
• 关于排序算法比较的问题
• 内部排序算法比较

几种经典排序算法优劣比较的C++程序实现

一、低级排序算法
1.选择排序
（1）排序过程
给定一个数值集合，循环遍历集合，每次遍历从集合中选择出最小或最大的放入集合的开头或结尾的位置，下次循环从剩余的元素集合中遍历找出最小的并如上操作，最后直至所有原集合元素都遍历完毕，排序结束。
（2）实现代码
//选择排序法
template
void Sort：：SelectSort（T* array， int size）
{
int minIndex；
for（int i = 0； i 《 size； i++）
{
minIndex = i；
for（int j = i + 1； j 《 size； j++）
{
if（array[minIndex] 》 array[j]）
{
minIndex = j；
}
}
if（minIndex ！= i）
{
Swap（array， i， minIndex）；
}
}
}
（3）分析总结
选择排序时间复杂度比较高，达到了O（n^2），每次选择都要遍历一遍无序区间。选择排序对一类重要的元素序列具有较好的效率，就是元素规模很大，而排序码却比较小的序列。另外要说明的是选择排序是一种不稳定的排序方法。
2.冒泡排序
（1）排序过程
冒泡排序的过程形如其名，就是依次比较相邻两个元素，优先级高（或大或小）的元素向后移动，直至到达序列末尾，无序区间就会相应地缩小。下一次再从无序区间进行冒泡操作，依此循环直至无序区间为1，排序结束。
（2）实现代码
//冒泡排序法
template
void Sort：：BubbleSort（T* array， int size）
{
for（int i = 0； i 《 size； i++）
{
for（int j = 1； j 《 size - i； j++）
{
if（array[j] 《 array[j - 1]）
{
Swap（array， j， j - 1）；
}
}
}
}
（3）分析总结
冒泡排序的时间复杂度也比较高，达到O（n^2），每次遍历无序区间都将优先级高的元素移动到无序区间的末尾。冒泡排序是一种稳定的排序方式。
二、高级排序算法
（1）排序过程
归并排序的原理比较简单，也是基于分治思想的。它将待排序的元素序列分成两个长度相等的子序列，然后为每一个子序列排序，然后再将它们合并成一个序列。
（2）实现代码
//归并排序
template
void Sort：：MergeSort（T* array， int left， int right）
{
if（left 《 right）
{
int mid = （left + right） / 2；
MergeSort（array， left， mid）；
MergeSort（array， mid + 1， right）；
Merge（array， left， mid， right）；
}
}
//合并两个已排好序的子链
template
void Sort：：Merge（T* array， int left， int mid， int right）
{
T* temp = new T[right - left + 1]；
int i = left， j = mid + 1， m = 0；
while（i 《= mid && j 《= right）
{
if（array[i] 《 array[j]）
{
temp[m++] = array[i++]；
}
else
{
temp[m++] = array[j++]；
}
}
while（i 《= mid）
{
temp[m++] = array[i++]；
}
while（j 《= right）
{
temp[m++] = array[j++]；
}
for（int n = left， m = 0； n 《= right； n++， m++）
{
array[n] = temp[m]；
}
delete temp；
}
（3）分析总结
归并排序最好、最差和平均时间复杂度都是O（nlogn），是一种稳定的排序算法。

数据结构中几种常见的排序算法之比较

实话实说，关于数据结构中几种常见的排序算法（例如：冒泡排序、SHELL排序、归并排序、快速排序等）的性能好坏，还不只是学好了数据结构这门课程就能够解决的问题，还必须要学习好、且精通掌握计算机软件专业的另外一门非常重要的课程，才能够解决这个问题。即：计算机算法复杂性理论。
只有同时把这门课程学好了，那么才能够真正掌握数据结构中的各种排序算法、以及各种查找算法中所有涉及到的：比较次数、以及交换次数，最终才能够根据具体的开发软件规模的不同，选择出一个适合开发该软件的最佳算法。

各种排序算法最好和最坏情况比较

都不知道怎么回答，各种排序说的也太多了，这里讲几种简单的吧，希望对你有帮助！
比如n个顺序存储元素进行排序，a做“哨兵”（即a不存数据，而是用作辅存空间使用）的情况
1 直接插入排序：比较次数 最少n-1次；最多(n-1)(n+2)/2
移动次数 最少0； 最多(n-1)(n+4)/2
使用一个辅助存储空间，是稳定的排序；

2 折半插入排序：比较次数 最少与最多同，都是n*log2n（其中2为底，下边表示同），
移动次数 最少0，最多时间复杂度为O(n2);(n的平方，以下也如此表示)；
使用一个辅助存储空间，是稳定的排序；

3 冒泡排序： 比较最少为：n-1次，最多时间复杂度表示为o(n2);
移动次数最少为0，最多时间复杂度表示为O(n2);
使用一个辅存空间，是稳定的排序；

4 简单选择排序： 比较次数没有多少之分，均是n(n-1)/2;
移动次数最少为0，最多为3(n-1);
使用一个辅存空间，是稳定的排序；

5 快速排序：比较和移动次数最少时间复杂度表示为O(n*log2n);
比较和移动次数最多的时间复杂度表示为O(n2);
使用的辅助存储空间最少为log2n，最多为n的平方；是不稳定的排序；

6 堆排序： 比较和移动次数没有好坏之分，都是O(n*log2n);
使用一个辅存空间，是不稳定的排序；

7 2-路归并排序：比较和移动次数没有好坏之分，都是O(n*log2n);
需要n个辅助存储空间，是稳定的排序；

另外还有很多的排序方法如 希尔排序，基数排序，2-路插入排序 等等很多的排序方法，这里就不一一列举了，希望列举的对你有帮助！

关于排序算法比较的问题

楼上的说法不准确吧，不能说比较和交换的次数不是一个级别的，交换也不是最多只有n次。比如一个逆序的数组进行升序的冒泡排序，交换就远远超过n次。
但是假设比较次数为P(n)，交换次数为Q(n)，那么因为交换发生在比较之后（基本上排序算法都是这样，楼主可以自己想想），必然有Q(n)《=P(n)。如果时间复杂度为T(n)，那么显然根据时间复杂度的定义（极限定义），用大O表示法可以忽略Q(n)项（或用P(n)代替Q(n)），仅用P对T进行表示。
因为大O表示法是对时间复杂度上限的一个估计，而这种每比较一次就需要交换的情况确实存在（最差情况），所以在T(n)中使用P(n)对Q(n)进行替换并不会扩大对上限估计，而只是乘以了系数2，在大O表示法中常数项是不写入的。
这些数学分析一般在国内的算法教材中都不写入的，MIT的《ITA》注重这方面的叙述。
关于总结其实楼主可以自己去搜，上来问这行为太懒了。不过我也帮你找来吧。

冒泡法：
这是最原始，也是众所周知的最慢的算法了。他的名字的由来因为它的工作看来象是冒泡： 复杂度为O(n*n)。当数据为正序，将不会有交换。复杂度为O(0)。
直接插入排序：O(n*n)
选择排序：O(n*n)
快速排序：平均时间复杂度log2(n)*n，所有内部排序方法中最高好的，大多数情况下总是最好的。
归并排序：log2(n)*n
堆排序：log2(n)*n
希尔排序：算法的复杂度为n的1.2次幂

内部排序算法比较

按平均时间将排序分为四类：

（1）平方阶(O(n2))排序 一般称为简单排序，例如直接插入、直接选择和冒泡排序；

（2）线性对数阶(O(nlgn))排序 如快速、堆和归并排序；

（3）O(n1+￡)阶排序 ￡是介于0和1之间的常数，即0《￡《1，如希尔排序；

（4）线性阶(O(n))排序 如桶、箱和基数排序。

各种排序方法比较 简单排序中直接插入最好，快速排序最快，当文件为正序时，直接插入和冒泡均最佳。 影响排序效果的因素 因为不同的排序方法适应不同的应用环境和要求，所以选择合适的排序方法应综合考虑下列因素：

①待排序的记录数目n；

②记录的大小(规模)；

③关键字的结构及其初始状态；

④对稳定性的要求；

⑤语言工具的条件；

⑥存储结构；

⑦时间和辅助空间复杂度等。

不同条件下，排序方法的选择

(1)若n较小(如n≤50)，可采用直接插入或直接选择排序。 当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插人，应选直接选择排序为宜。

(2)若文件初始状态基本有序(指正序)，则应选用直接插人、冒泡或随机的快速排序为宜；

(3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。 快速排序是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短； 堆排序所需的辅助空间少于快速排序，并且不会出现快速排序可能出现的最坏情况。这两种排序都是不稳定的。 若要求排序稳定，则可选用归并排序。但本章介绍的从单个记录起进行两两归并的 排序算法并不值得提倡，通常可以将它和直接插入排序结合在一起使用。先利用直接插入排序求得较长的有序子文件，然后再两两归并之。因为直接插入排序是稳定的，所以改进后的归并排序仍是稳定的。

(4)在基于比较的排序方法中，每次比较两个关键字的大小之后，仅仅出现两种可能的转移，因此可以用一棵二叉树来描述比较判定过程。 当文件的n个关键字随机分布时，任何借助于“比较“的排序算法，至少需要O(nlgn)的时间。

百度文库里也有说明，详见：
#include《stdio.h》
#include《stdlib.h》
#include《string.h》
#include《time.h》
#define LIST_INIT_SIZE 50000
int bj1,yd1,n;
clock_t start_t,end_t;
typedef struct
{
int key;
}ElemType;
typedef struct
{
ElemType *elem;
int length;
}SqList;
void addlist(SqList &L)
{
int i;
a: printf(“请输入你要输入的个数:“);
scanf(“%d“,&n);
if(n》50000)
{
printf(“超出范围重新输入!!!\n“);
goto a;
}
L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L.elem)exit(0);
L.length=0;
for(i=1;i《n+1;i++)
{
b: L.elem[i].key=rand();
if(L.elem[i].key》30000)goto b;
++L.length;
}
}
void SelectSort(SqList &L)//选择
{
start_t=clock();
int i,j,k,bj=0,yd=0;
for(i=1;i《L.length;i++)
{
k=i;
for(j=i+1;j《L.length;j++)
{
bj++;
if(L.elem[j].key《L.elem[k].key)k=j;
}
if(i!=k)
{
L.elem.key=L.elem[i].key;
L.elem[i].key=L.elem[k].key;
L.elem[k].key=L.elem.key;
yd+=3;
}
}
end_t=clock();
printf(“比较次数为 %d移动次数为 %d\n“,bj,yd);
printf(“排序用时为 %f\n“,float(end_t-start_t)/CLK_TCK);
}
void qipao(SqList &L)//起泡
{
start_t=clock();
int i=1,j,bj=0,yd=0;
while(i《L.length)
{
for(j=1;j《L.length;j++)
{
bj++;
if(L.elem[j].key》L.elem[j+1].key)
{
L.elem.key=L.elem[j].key;
L.elem[j].key=L.elem[j+1].key;
L.elem[j+1].key=L.elem.key;
yd+=3;
}
}
i++;
}
end_t=clock();
printf(“比较次数为 %d移动次数为 %d\n“,bj,yd);
printf(“排序用时为 %f\n“,float(end_t-start_t)/CLK_TCK);
}
void InsertSort(SqList &L)//直接插入
{
start_t=clock();
int i,j,yd=0,bj=0;
for(i=2;i《=L.length;i++)
{
if(L.elem[i].key《L.elem[i-1].key)
{
L.elem.key=L.elem[i].key;
yd++;
j=i-1;
bj++;
while(L.elem.key《L.elem[j].key)
{
L.elem[j+1].key=L.elem[j].key;
j--;
yd++;
bj++;
}
L.elem[j+1].key=L.elem.key;
yd++;
}
}
end_t=clock();
printf(“比较次数为 %d移动次数为 %d\n“,bj,yd);
printf(“排序用时为 %f\n“,float(end_t-start_t)/CLK_TCK);
}
void xier(SqList &L)//希尔
{
start_t=clock();
int i,d=L.length/2,j,w=0,k,yd=0,bj=0;
while(w《d)
{
w=1;
for(i=w;i《L.length;i=i+d)
{
k=i;
for(j=i+d;j《L.length;j=j+d)
{
if(L.elem[i].key》L.elem[j].key)
{
k=j;
bj++;
}
}
if(i!=k)
{
L.elem.key=L.elem[i].key;
L.elem[i].key=L.elem[k].key;
L.elem[k].key=L.elem.key;
yd+=3;
}
w++;
}
d=d/2;
w=1;
}
end_t=clock();
printf(“比较次数为 %d移动次数为 %d\n“,bj,yd);
printf(“排序用时为 %f\n“,float(end_t-start_t)/CLK_TCK);
}

void BeforeSort()
{
yd1=0,bj1=0;
}
void display(int m,int n)
{
printf(“比较次数为 %d移动次数为 %d\n“,m,n);
}
int Partition(SqList &L,int low,int high)//快速排序
{
int pivotkey;
L.elem=L.elem[low];
yd1++;
pivotkey=L.elem[low].key;
while (low《high)
{
yd1++;
while(low《high&&L.elem[high].key》=pivotkey)
--high;
L.elem[low]=L.elem[high];
bj1++;
yd1++;
while (low《high&&L.elem[low].key《=pivotkey)
++low;
L.elem[high]=L.elem[low];
bj1++;
yd1++;
}
L.elem[low]=L.elem;
yd1++;
return low;
}
void QSort(SqList &L,int low,int high)
{
int pivotloc;
if(low《high)
{
pivotloc=Partition(L,low,high);
QSort(L,low,pivotloc-1);
QSort(L,pivotloc+1,high);
}
}
void QuickSort(SqList &L)
{
start_t=clock();
BeforeSort();
QSort(L,1,L.length);
display(yd1,bj1);
end_t=clock();
printf(“排序用时为 %f\n“,float(end_t-start_t)/CLK_TCK);
}
void Merge(ElemType R,ElemType R1,int low,int m,int high)//归并
{
int i=low, j=m+1, k=low;
while(i《=m&&j《=high)
{
if(R[i].key《=R[j].key)
{
bj1++;
R1[k]=R[i];
yd1++;
i++;
k++;
}
else
{
bj1++;
R1[k]=R[j];
yd1++;
j++;
k++;
}
}
while(i《=m)
{
R1[k]=R[i];
yd1++;
i++;
k++;
}
while(j《=high)
{
R1[k]=R[j];
yd1++;
j++;
k++;
}
}
void MergePass(ElemType R,ElemType R1,int length, int n)
{
int i=0,j;
while(i+2*length-1《n)
{
Merge(R,R1,i,i+length-1,i+2*length-1);
i=i+2*length;
}
if(i+length-1《n-1)
Merge(R,R1,i,i+length-1,n-1);
else
for(j=i;j《n;j++)
R1[j]=R[j];
}
void MSort(ElemType R,ElemType R1,int n)
{
int length=1;
while (length《n)
{
MergePass(R,R1,length,n);
length=2*length;
MergePass(R1,R,length,n);
length=2*length;
}
}
void MergeSort(SqList &L)
{
start_t=clock();
BeforeSort();
MSort(L.elem,L.elem,L.length);
display(yd1,bj1);
end_t=clock();
printf(“排序用时为 %f\n“,float(end_t-start_t)/CLK_TCK);
}

void main()
{
SqList L;
addlist(L);
printf(“起泡排序: \n“);
qipao(L);
addlist(L);
printf(“直插排序: \n“);
InsertSort(L);
addlist(L);
printf(“选择排序: \n“);
SelectSort(L);
addlist(L);
printf(“希尔排序: \n“);
xier(L);
addlist(L);
printf(“快速排续: \n“);
QuickSort(L);
addlist(L);
printf(“归并排序: \n“);
MergeSort(L);
}