7中排序算法学习总结（图解+程序代码）

7中排序算法学习总结（图解+程序代码）

2017年06月08日 17:08:49

阅读数：335

//二分法排序（二分法查找）

#include <stdio.h>

void chaxu(int a[],int x,int n)

{

int i,k,mid,p=0,q=n-1;

while(p<=q)

{

mid=(p+q)/2;

扫描二维码关注公众号，回复： 2584645 查看本文章

if(x>=a[mid])

p=mid+1;

else

q=mid-1;

}

for(i=n-1;i>=p;i--)

a[i+1]=a[i];

a[p]=x;

}

int main()

{

int a[100],i,n,x;

scanf("%d%d",&n,&x);

for(i=0;i<n;i++)

scanf("%d",&a[i]);

chaxu(a,x,n);

for(i=0;i<=n;i++)

printf("%d\t",a[i]);

printf("\n");

return 0;

}//

 

我们通常所说的排序算法往往指的是内部排序算法，即数据记录在内存中进行排序。

　　排序算法大体可分为两种：

　　　　一种是比较排序，时间复杂度O(nlogn) ~ O(n^2)，主要有：冒泡排序，选择排序，插入排序，归并排序，堆排序，快速排序等。

　　　　另一种是非比较排序，时间复杂度可以达到O(n)，主要有：计数排序，基数排序，桶排序等。

常用排序算法的时间复杂度：

这里介绍一下稳定性的概念。如果原序列中有A1 = A2，排序前A1在A2的前面，排序后A1仍然在A2的前面，则说明这种排序算法是稳定的。否则不稳定。

并不是说冒泡排序法就一直是稳定的，如果程序代码中有a[i]>=a[i+1]则交换顺序的语句，就将会把原来相等的数值交换位置，则冒牌排序算法就变为不稳定的了。反过来不稳定的排序算法也可以变成稳定的。

现再开始通过程序代码和图解的方式介绍各种常用的排序算法

一、冒泡排序法

算法思想：

　　冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错-误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

步骤：

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

算法流程图：

冒泡排序动态效果：

算法实现：

[cpp] view plain copy

1. <span style="font-family:SimSun;">/*冒泡排序法*/  
2. // 分类 -------------- 内部比较排序  
3. // 数据结构 ---------- 数组  
4. // 最差时间复杂度 ---- O(n^2)  
5. // 最优时间复杂度 ---- 如果序列在一开始已经大部分排序过的话,会接近O(n)  
6. // 平均时间复杂度 ---- O(n^2)  
7. // 所需辅助空间 ------ O(1)  
8. // 稳定性 ------------ 稳定  
9.   
10. #include <stdio.h>  
11. void Bubble_sort(int *a,int n)  
12. {  
13.     int i,j;  
14.     for(i = 0;i<n;i++)  
15.     {  
16.         for(j = 0;j < n-i-1;j++)  
17.         {  
18.             if(a[j] > a[j+1])  
19.             {  
20.                 int temp = a[j];  
21.                 a[j] = a[j+1];  
22.                 a[j+1] = temp;  
23.             }  
24.         }  
25.     }  
26. }  
27. int main(int argc ,char *argv[])  
28. {  
29.     int i;  
30.     int array[10] = {13,58,61,43,97,6,1,84,66,31};  
31.     printf("排序后的数组为：");  
32.     Bubble_sort(array,10);//调用冒泡排序函数，传入数组名和数组长度  
33.     for(i = 0;i<sizeof(array)/sizeof(int);i++)//这里可使用sizeof来求出数组长度  
34.         printf("%d  ",array[i]);  
35.     return 0;  
36. }  
37. </span>  

 

1. 二、简单选择排序——选择排序法
2.  
3. 算法思想：
4. 在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

步骤：

第一趟，从n 个记录中找出关键码最小的记录与第一个记录交换；

第二趟，从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换；

以此类推.....

第i 趟，则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换，

直到整个序列按关键码有序。

 

算法流程图：

选择排序动态效果：

算法实现：

[cpp] view plain copy

1. <span style="font-family:SimSun;">/*选择排序法*/  
2. // 分类 -------------- 内部比较排序  
3. // 数据结构 ---------- 数组  
4. // 最差时间复杂度 ---- O(n^2)  
5. // 最优时间复杂度 ---- O(n^2)  
6. // 平均时间复杂度 ---- O(n^2)  
7. // 所需辅助空间 ------ O(1)  
8. // 稳定性 ------------ 不稳定  
9.   
10. #include <stdio.h>  
11. void Selection_sort(int *a,int n)  
12. {  
13.     int i,j,k;  
14.     for(i = 0 ; i < n-1 ; i++)  
15.     {  
16.         k = i;  
17.         for(j = i+1 ; j < n ; j++)  
18.         {  
19.             if(a[k] > a[j])  
20.                 k = j;  //找出最小值的数组下标  
21.         }  
22.         if(k != i)  //如果最小值的下标和要交换的位置下标不相等，就交换位置  
23.         {  
24.             int temp = a[k];  
25.             a[k] = a[i];  
26.             a[i] = temp;  
27.         }  
28.     }  
29. }  
30. int main(int argc ,char *argv[])  
31. {  
32.     int i;  
33.     int array[10] = {8, 5, 2, 6, 9, 3, 1, 4, 0, 7};  
34.     printf("排序后的数组为：");  
35.     Selection_sort(array,10);//调用冒泡排序函数，传入数组名和数组长度  
36.     for(i = 0;i<sizeof(array)/sizeof(int);i++)//这里可使用sizeof来求出数组长度  
37.         printf("%d  ",array[i]);  
38.     return 0;  
39. }  
40.   
41. </span>  

算法实现过程动态图示：

 

三、直接插入排序

算法思想：

插入排序是一种简单直观的排序算法。它的工作原理非常类似于我们抓扑克牌

 

　　对于未排序数据(右手抓到的牌)，在已排序序列(左手已经排好序的手牌)中从后向前扫描，找到相应位置并插入。

　　插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

步骤：

1. 从第一个元素开始，该元素可以认为已经被排序
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5. 将新元素插入到该位置后
6. 重复步骤2~5

算法流程图：

插入排序动态效果：

算法实现：

[cpp] view plain copy

1. <span style="font-family:SimSun;">/*简单插入排序*/  
2. // 分类 ------------- 内部比较排序  
3. // 数据结构 ---------- 数组  
4. // 最差时间复杂度 ---- 最坏情况为输入序列是降序排列的,此时时间复杂度O(n^2)  
5. // 最优时间复杂度 ---- 最好情况为输入序列是升序排列的,此时时间复杂度O(n)  
6. // 平均时间复杂度 ---- O(n^2)  
7. // 所需辅助空间 ------ O(1)  
8. // 稳定性 ------------ 稳定  
9.   
10. #include <stdio.h>  
11. void Insertion_sort(int *a, int n)  
12. {  
13.     int i,j,get;  
14.     for (i = 1; i < n; i++)             // 类似抓扑克牌排序  
15.     {  
16.         get = a[i];                     // 右手抓到一张扑克牌  
17.         j = i - 1;                      // 拿在左手上的牌总是排序好的  
18.         while (j >= 0 && a[j] > get)    // 将抓到的牌与手牌从右向左进行比较  
19.         {  
20.             a[j + 1] = a[j];            // 如果该手牌比抓到的牌大,就将其右移  
21.             j--;  
22.         }  
23.         a[j + 1] = get;// 直到该手牌比抓到的牌小(或二者相等),将抓到的牌插入到该手牌右边(相等元素的相对次序未变,所以插入排序是稳定的)  
24.     }  
25. }  
26.   
27. int main(int argc,char *argv[])  
28. {  
29.     int i;  
30.     int array[8] = {6, 5, 3, 1, 8, 7, 2, 4};  
31.     Insertion_sort(array,8);  
32.     printf("插入排序后的数组：\n");  
33.     for(i = 0;i<sizeof(array)/sizeof(int);i++)  
34.     {  
35.          printf("%d  ",array[i]);  
36.     }  
37.     return 0;  
38. }  
39. </span>  

 

算法实现过程动态图示：

四、插入排序——希尔排序

算法思想：

希尔排序，也称递减增量排序算法，是插入排序的一种高速而稳定的改进版本。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

1、插入排序在对几乎已经排好序的数据操作时， 效率高， 即可以达到线性排序的效率

2、但插入排序一般来说是低效的， 因为插入排序每次只能将数据移动一位>

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

步骤：

1. 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
2. 按增量序列个数k，对序列进行k 趟排序；
3. 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度

算法流程图：

希尔排序动态效果：

 

算法实现：

[cpp] view plain copy

1. <span style="font-family:SimSun;">/*希尔排序法*/  
2. // 分类 -------------- 内部比较排序  
3. // 数据结构 ---------- 数组  
4. // 最差时间复杂度 ---- 根据步长序列的不同而不同。已知最好的为O(n(logn)^2)  
5. // 最优时间复杂度 ---- O(n)  
6. // 平均时间复杂度 ---- 根据步长序列的不同而不同。  
7. // 所需辅助空间 ------ O(1)  
8. // 稳定性 ------------ 不稳定  
9.   
10. #include <stdio.h>  
11. void Shell_sort(int *a,int n)  
12. {  
13.     int i,j,h = 0,get;  
14.     while (h <= n)                          // 生成初始增量  
15.     {  
16.         h = 3*h + 1;  
17.     }  
18.     while (h >= 1)  
19.     {  
20.         for (i = h; i < n; i++)  
21.         {  
22.             j = i - h;  
23.             get = a[i];  
24.             while ((j >= 0) && (a[j] > get))  
25.             {  
26.                 a[j + h] = a[j];  
27.                 j = j - h;  
28.             }  
29.             a[j + h] = get;  
30.         }  
31.         h = (h - 1) / 3;                    // 递减增量  
32.     }  
33. }  
34.   
35. int main(int argc,char *argv[])  
36. {  
37.     int i;  
38.     int array[10] = {13,58,61,43,97,6,1,84,66,31};  
39.     Shell_sort(array,10);  
40.     printf("希尔排序后的数组为：\n");  
41.     for(i = 0;i<sizeof(array)/sizeof(int);i++)  
42.         printf("%d  ",array[i]);  
43.     return 0;  
44. }  
45. </span>  

 

希尔排序是不稳定的排序算法，虽然一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱。

比如序列：{ 3, 5, 10, 8, 7, 2, 8, 1, 20, 6 }，h=2时分成两个子序列 { 3, 10, 7, 8, 20 } 和  { 5, 8, 2, 1, 6 } ，未排序之前第二个子序列中的8在前面，现在对两个子序列进行插入排序，得到 { 3, 7, 8, 10, 20 } 和 { 1, 2, 5, 6, 8 } ，即 { 3, 1, 7, 2, 8, 5, 10, 6, 20, 8 } ，两个8的相对次序发生了改变。

五、选择排序——堆排序

算法思想：

堆排序是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构（通常堆是通过一维数组来实现的），并同时满足堆的性质：即子结点的键值总是小于（或者大于）它的父节点。

 

堆的定义如下：具有n个元素的序列（k1,k2,...,kn),当且仅当满足

时称之为堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最小项（小顶堆）。
若以一维数组存储一个堆，则堆对应一棵完全二叉树，且所有非叶结点的值均不大于(或不小于)其子女的值，根结点（堆顶元素）的值是最小(或最大)的。如：

（a）大顶堆序列：（96, 83,27,38,11,09)

  (b)  小顶堆序列：（12，36，24，85，47，30，53，91）

 

初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树（一维数组存储二叉树），调整它们的存储序，使之成为一个堆，将堆顶元素输出，得到n 个元素中最小(或最大)的元素，这时堆的根节点的数最小（或者最大）。然后对前面(n-1)个元素重新调整使之成为堆，输出堆顶元素，得到n 个元素中次小(或次大)的元素。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。称这个过程为堆排序。

因此，实现堆排序需解决两个问题：
1. 如何将n 个待排序的数建成堆；
2. 输出堆顶元素后，怎样调整剩余n-1 个元素，使其成为一个新堆。

首先讨论第二个问题：输出堆顶元素后，对剩余n-1元素重新建成堆的调整过程。
调整小顶堆的方法：

1）设有m 个元素的堆，输出堆顶元素后，剩下m-1 个元素。将堆底元素送入堆顶（（最后一个元素与堆顶进行交换），堆被破坏，其原因仅是根结点不满足堆的性质。

2）将根结点与左、右子树中较小元素的进行交换。

3）若与左子树交换：如果左子树堆被破坏，即左子树的根结点不满足堆的性质，则重复方法 （2）.

4）若与右子树交换，如果右子树堆被破坏，即右子树的根结点不满足堆的性质。则重复方法 （2）.

5）继续对不满足堆性质的子树进行上述交换操作，直到叶子结点，堆被建成。

称这个自根结点到叶子结点的调整过程为筛选。如图：

再讨论对n 个元素初始建堆的过程。
建堆方法：对初始序列建堆的过程，就是一个反复进行筛选的过程。

1）n 个结点的完全二叉树，则最后一个结点是第n/2个结点的子树。

2）筛选从第n/2个结点为根的子树开始，该子树成为堆。

3）之后向前依次对各结点为根的子树进行筛选，使之成为堆，直到根结点。

如图建堆初始过程：无序序列：（49，38，65，97，76，13，27，49）    

 

步骤：

1. 创建一个堆
2. 把堆顶元素(最大值)和堆尾元素互换
3. 把堆的尺寸缩小1，并调用heapify(A, 0)从新的堆顶元素开始进行堆调整
4. 重复步骤2，直到堆的尺寸为1

堆排序动态效果：

算法实现：

[cpp] view plain copy

1. <span style="font-family:SimSun;">/*堆排序算法*/  
2. // 分类 -------------- 内部比较排序  
3. // 数据结构 ---------- 数组  
4. // 最差时间复杂度 ---- O(nlogn)  
5. // 最优时间复杂度 ---- O(nlogn)  
6. // 平均时间复杂度 ---- O(nlogn)  
7. // 所需辅助空间 ------ O(1)  
8. // 稳定性 ------------ 不稳定  
9.   
10. #include <stdio.h>  
11. int heapsize;    // 堆大小  
12.   
13. void exchange(int A[], int i, int j)    // 交换A[i]和A[j]  
14. {  
15.     int temp = A[i];  
16.     A[i] = A[j];  
17.     A[j] = temp;  
18. }  
19.   
20. void heapify(int A[], int i)            // 堆调整函数(这里使用的是最大堆)  
21. {  
22.     int leftchild = 2 * i + 1;          // 左孩子索引  
23.     int rightchild = 2 * i + 2;         // 右孩子索引  
24.     int largest;                        // 选出当前结点与左右孩子之中的最大值  
25.     if (leftchild < heapsize && A[leftchild] > A[i])  
26.         largest = leftchild;  
27.     else  
28.         largest = i;  
29.     if (rightchild < heapsize && A[rightchild] > A[largest])  
30.         largest = rightchild;  
31.     if (largest != i)  
32.     {  
33.         exchange(A, i, largest);        // 把当前结点和它的最大(直接)子节点进行交换  
34.         heapify(A, largest);            // 递归调用，继续从当前结点向下进行堆调整  
35.     }  
36. }  
37.   
38. void buildheap(int A[], int n)          // 建堆函数  
39. {  
40.     int i;  
41.     heapsize = n;  
42.     for ( i = heapsize / 2 - 1; i >= 0; i--) // 对每一个非叶结点  
43.         heapify(A, i);                  // 不断的堆调整  
44. }  
45.   
46. void heapsort(int A[], int n)  
47. {  
48.     int i;  
49.     buildheap(A, n);  
50.     for (i = n - 1; i >= 1; i--)  
51.     {  
52.         exchange(A, 0, i); // 将堆顶元素(当前最大值)与堆的最后一个元素互换(该操作很有可能把后面元素的稳定性打乱,所以堆排序是不稳定的排序算法)  
53.         heapsize--;        // 从堆中去掉最后一个元素  
54.         heapify(A, 0);     // 从新的堆顶元素开始进行堆调整  
55.     }  
56. }  
57.   
58. int main()  
59. {  
60.     int i;  
61.     int A[] = { 5, 2, 9, 4, 7, 6, 1, 3, 8 };// 从小到大堆排序  
62.     int n = sizeof(A) / sizeof(int);  
63.     heapsort(A, n);  
64.     printf("堆排序结果：");  
65.     for (i = 0; i < n; i++)  
66.     {  
67.         printf("%d ", A[i]);  
68.     }  
69.     printf("\n");  
70.     return 0;  
71. }  
72. </span>  

 

堆排序是不稳定的排序算法，不稳定发生在堆顶元素与A[i]交换的时刻。

比如序列：{ 9, 5, 7, 5 }，堆顶元素是9，堆排序下一步将9和第二个5进行交换，得到序列 { 5, 5, 7, 9 }，再进行堆调整得到{ 7,5, 5, 9 }，重复之前的操作最后得到{ 5, 5, 7, 9 }从而改变了两个5的相对次序。

 

六、归并排序

算法思想：

归并排序是创建在归并操作上的一种有效的排序算法，效率为O(nlogn)，1945年由冯·诺伊曼首次提出。

　　归并排序的实现分为递归实现与非递归(迭代)实现。递归实现的归并排序是算法设计中分治策略的典型应用，我们将一个大问题分割成小问题分别解决，然后用所有小问题的答案来解决整个大问题。非递归(迭代)实现的归并排序首先进行是两两归并，然后四四归并，然后是八八归并，一直下去直到归并了整个数组。

归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

步骤：

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
4. 重复步骤3直到某一指针到达序列尾
5. 将另一序列剩下的所有元素直接复制到合并序列尾

算法流程图：

归并排序动态效果：

算法实现：

[cpp] view plain copy

1. <span style="font-family:SimSun;">/*归并排序算法*/  
2. // 分类 -------------- 内部比较排序  
3. // 数据结构 ---------- 数组  
4. // 最差时间复杂度 ---- O(nlogn)  
5. // 最优时间复杂度 ---- O(nlogn)  
6. // 平均时间复杂度 ---- O(nlogn)  
7. // 所需辅助空间 ------ O(n)  
8. // 稳定性 ------------ 稳定  
9.   
10. #include <stdio.h>  
11. #include <limits.h>                // 包含极限值的头文件，这里用到了无穷大INT_MAX  
12.   
13. int L[10];    // 两个子数组定义成全局变量（辅助存储空间,大小正比于元素的个数）  
14. int R[10];  
15.   
16. void merge(int A[], int left, int middle, int right)// 合并两个已排好序的数组A[left...middle]和A[middle+1...right]  
17. {  
18.     int i,j,k;  
19.     int n1 = middle - left + 1;     // 两个数组的大小  
20.     int n2 = right - middle;  
21.     for (i = 0; i < n1; i++)    // 把两部分分别拷贝到两个数组中  
22.         L[i] = A[left + i];  
23.     for (j = 0; j < n2; j++)  
24.         R[j] = A[middle + j + 1];  
25.     L[n1] = INT_MAX;                // 使用无穷大作为哨兵值放在子数组的末尾  
26.     R[n2] = INT_MAX;                // 这样可以免去检查某个子数组是否已读完的步骤  
27.     i = 0;  
28.     j = 0;  
29.     for (k = left; k <= right; k++) // 依次比较两个子数组中的值，每次取出更小的那一个放入原数组  
30.     {  
31.         if (L[i] <= R[j])  
32.         {  
33.             A[k] = L[i];  
34.             i++;  
35.         }  
36.         else  
37.         {  
38.             A[k] = R[j];  
39.             j++;  
40.         }  
41.     }  
42.   
43. }  
44.   
45. void mergesort_recursion(int A[], int left, int right) // 递归实现的归并排序(自顶向下)  
46. {  
47.     int middle = (left + right) / 2;  
48.     if (left < right)          // 当待排序的序列长度为1时(left == right)，递归“开始回升”  
49.     {  
50.         mergesort_recursion(A, left, middle);  
51.         mergesort_recursion(A, middle + 1, right);  
52.         merge(A, left, middle, right);  
53.     }  
54. }  
55.   
56. void mergesort_iteration(int A[], int left, int right)  // 非递归(迭代)实现的归并排序(自底向上)  
57. {  
58.     int size;  
59.     int low, middle, high;    // 子数组索引,前一个为A[low...middle],后一个子数组为A[middle+1...high]  
60.     for (size = 1; size <= right - left; size *= 2) // 子数组的大小初始为1,每轮翻倍  
61.     {  
62.         low = left;  
63.         while (low + size - 1 <= right - 1 )// 后一个子数组存在(需要归并)  
64.         {  
65.             middle = low + size - 1;  
66.             high = middle + size;  
67.             if(high > right)// 后一个子数组大小不足size  
68.                 high = right;  
69.             merge(A, low, middle, high);    //合并  
70.             low = high + 1;     //前一个子数组索引向后移动  
71.         }  
72.     }  
73. }  
74.   
75. int main()  
76. {  
77.     int i;  
78.     int A1[] = { 6, 5, 3, 1, 8, 7, 2, 4 };    // 从小到大归并排序  
79.     int A2[] = { 6, 5, 3, 1, 8, 7, 2, 4 };  
80.     int n1 = sizeof(A1) / sizeof(int);  
81.     int n2 = sizeof(A2) / sizeof(int);  
82.     mergesort_recursion(A1, 0, n1 - 1);       // 递归实现  
83.     mergesort_iteration(A2, 0, n2 - 1);       // 非递归实现  
84.     printf("递归实现的归并排序结果：");  
85.     for (i = 0; i < n1; i++)  
86.     {  
87.         printf("%d ",A1[i]);  
88.     }  
89.     printf("\n");  
90.     printf("非递归实现的归并排序结果：");  
91.     for (i = 0; i < n2; i++)  
92.     {  
93.         printf("%d ", A2[i]);  
94.     }  
95.     printf("\n");  
96.     return 0;  
97. }  
98. </span>  

 

 

上述代码对序列{ 6, 5, 3, 1, 8, 7, 2, 4 }进行归并排序的实例如下　

 

七、快速排序

算法思想：

快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序n个元素要O(nlogn)次比较。在最坏状况下则需要O(n^2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他O(nlogn)算法更快，因为它的内部循环可以在大部分的架构上很有效率地被实现出来。

快速排序使用分治策略(Divide and Conquer)来把一个序列分为两个子序列。

步骤：

1. 从序列中挑出一个元素，作为"基准"(pivot).
2. 把所有比基准值小的元素放在基准前面，所有比基准值大的元素放在基准的后面（相同的数可以到任一边），这个称为分区(partition)操作。
3. 对每个分区递归地进行步骤1~3，递归的结束条件是序列的大小是0或1，这时整体已经被排好序了。

算法流程图：

 

快速排序法动态效果：

算法实现：

[cpp] view plain copy

1. <span style="font-family:SimSun;">/*快速排序法*/  
2. // 分类 ------------ 内部比较排序  
3. // 数据结构 --------- 数组  
4. // 最差时间复杂度 ---- 每次选取的基准都是最大的元素（或者每次都是最小），导致每次只划分出了一个子序列，需要进行n-1次划分才能结束递归，时间复杂度为O(n^2)  
5. // 最优时间复杂度 ---- 每次选取的基准都能使划分均匀，只需要logn次划分就能结束递归，时间复杂度为O(nlogn)  
6. // 平均时间复杂度 ---- O(nlogn)  
7. // 所需辅助空间 ------ O(logn)～O(n),主要是递归造成的栈空间的使用(用来保存left和right等局部变量),取决于递归树的深度  
8. //                   一般为O(logn),最差为O(n)（基本有序的情况）  
9. // 稳定性 ---------- 不稳定  
10.   
11. #include <stdio.h>  
12.   
13. int quicksort(int v[], int left, int right) //传入数组的最低和最高的下标  
14. {  
15.     if(left < right)  
16.     {  
17.         int key = v[left];  //将数组最左边的值作为基准值用以比较  
18.         int low = left;  
19.         int high = right;  
20.         while(low < high)   //遍历数组  
21.         {  
22.             while(low < high && v[high] >= key)     //将大于等于基准值的值放在数组右边  
23.             {  
24.                 high--;     //最高位数组下标自减  
25.             }  
26.             v[low] = v[high];   //如果高位下标的值小于基准值就放到数组左边  
27.             while(low < high && v[low] < key)   //将小于基准值的值放在数组左边  
28.             {  
29.                 low++;      //最低位数组下标自增  
30.             }  
31.             v[high] = v[low];   //如果低位下标的值大于基准值就放到数组右边  
32.         }  
33.         v[low] = key;   //最后将基准值放入数组  
34.         quicksort(v,left,low-1);    //遍历调用排序函数  
35.         quicksort(v,low+1,right);  
36.     }  
37. }  
38.   
39. int main(int argc, char *argv[])  
40. {  
41.   
42.     int array[10] = {8,1,4,2,10,3,5,9,7,6};  
43.     int i;  
44.     printf("快速排序后的数组为：");  
45.     quicksort(array,0,9);  
46.     for( i = 0; i < 10; i++ )  
47.         printf("%d ",array[i]);  
48.     printf("\n");  
49.     return 0;  
50. }  
51. </span>  

 

快速排序是不稳定的排序算法，不稳定发生在基准元素与A[tail+1]交换的时刻。

比如序列：{ 1, 3, 4, 2, 8, 9, 8, 7, 5 }，基准元素是5，一次划分操作后5要和第一个8进行交换，从而改变了两个元素8的相对次序。

 

 

总结

各种排序的稳定性，时间复杂度和空间复杂度总结：

 我们比较时间复杂度函数的情况：

 

                             时间复杂度函数O(n)的增长情况

所以对n较大的排序记录。一般的选择都是时间复杂度为O(nlog2n)的排序方法。

 

时间复杂度来说：

(1)平方阶(O(n2))排序
　　各类简单排序:直接插入、直接选择和冒泡排序；
 (2)线性对数阶(O(nlog2n))排序
　　快速排序、堆排序和归并排序；
 (3)O(n1+§))排序,§是介于0和1之间的常数。

       希尔排序
(4)线性阶(O(n))排序
　　基数排序，此外还有桶、箱排序。

说明：

当原表有序或基本有序时，直接插入排序和冒泡排序将大大减少比较次数和移动记录的次数，时间复杂度可降至O（n）；

而快速排序则相反，当原表基本有序时，将蜕化为冒泡排序，时间复杂度提高为O（n2）；

原表是否有序，对简单选择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。

 

稳定性：

排序算法的稳定性:若待排序的序列中，存在多个具有相同关键字的记录，经过排序， 这些记录的相对次序保持不变，则称该算法是稳定的；若经排序后，记录的相对 次序发生了改变，则称该算法是不稳定的。 
     稳定性的好处：排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。另外，如果排序算法稳定，可以避免多余的比较；

稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序

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

 

选择排序算法准则：

每种排序算法都各有优缺点。因此，在实用时需根据不同情况适当选用，甚至可以将多种方法结合起来使用。

选择排序算法的依据

影响排序的因素有很多，平均时间复杂度低的算法并不一定就是最优的。相反，有时平均时间复杂度高的算法可能更适合某些特殊情况。同时，选择算法时还得考虑它的可读性，以利于软件的维护。一般而言，需要考虑的因素有以下四点：

1．待排序的记录数目n的大小；

2．记录本身数据量的大小，也就是记录中除关键字外的其他信息量的大小；

3．关键字的结构及其分布情况；

4．对排序稳定性的要求。

设待排序元素的个数为n.

1）当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。

   快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；
       堆排序 ：  如果内存空间允许且要求稳定性的，

       归并排序：它有一定数量的数据移动，所以我们可能过与插入排序组合，先获得一定长度的序列，然后再合并，在效率上将有所提高。

2）  当n较大，内存空间允许，且要求稳定性 =》归并排序

3）当n较小，可采用直接插入或直接选择排序。

    直接插入排序：当元素分布有序，直接插入排序将大大减少比较次数和移动记录的次数。

    直接选择排序 ：元素分布有序，如果不要求稳定性，选择直接选择排序

5）一般不使用或不直接使用传统的冒泡排序。

6）基数排序
它是一种稳定的排序算法，但有一定的局限性：
1、关键字可分解。
2、记录的关键字位数较少，如果密集更好
3、如果是数字时，最好是无符号的，否则将增加相应的映射复杂度，可先将其正负分开排序。

 

注明：转载请提示出处：http://blog.csdn.net/hguisu/article/details/7776068

  http://www.cnblogs.com/eniac12/p/5329396.html#s2