排序算法

 

转载整理自7-sevens大佬，本文仅供本人学习使用，请勿用作其他用途，如有所需，请联系大佬本人！！！

原文链接合集附在本文底部。

---

一、排序算法系列目录说明

冒泡排序（Bubble Sort）
插入排序（Insertion Sort）
希尔排序（Shell Sort）
选择排序（Selection Sort）
快速排序（Quick Sort）
归并排序（Merge Sort）
堆排序（Heap Sort）
计数排序（Counting Sort）
桶排序（Bucket Sort）
基数排序（Radix Sort）

---

二、排序算法简介说明

1. 定义
将一组杂乱无章的数据按一定的规律顺次排列起来。例如：

输入：a1，a2，a3，…，an

输出：a1’，a2’，a3’，…，an’（满足a1′ <= a2′ <= a3′ <= … <= an’排列）

2. 算法性能评估术语言
稳定：如果a原本在b前面，而a=b时，排序之后a仍然在b的前面。
不稳定：如果a原本在b的前面，而a=b时，排序之后a可能出现在b的后面。

内排序：所有排序操作都在内存中完成。
外排序：通常是由于数据太大，不能同时存放在内存中，根据排序过程的需要而在外存与内存之间 数据传输才能进行。

时间复杂度：时间频度，一个算法执行所耗费的时间。算法中通常用数据比较次数与数据移动次数 进行衡量。
空间复杂度：算法执行所需要的内存大小。
 

---

三、冒泡排序（Bubble Sort）

1. 基本思想

冒泡排序是一种交换排序，核心是冒泡，把数组中最小的那个往上冒，冒的过程就是和他相邻的元素交换。

重复走访要排序的数列，通过两两比较相邻记录的排序码。排序过程中每次从后往前冒一个最小值，且每次能确定一个数在序列中的最终位置。若发生逆序，则交换；有俩种方式进行冒泡，一种是先把小的冒泡到前边去，另一种是把大的元素冒泡到后边。

趣味解释：
有一群泡泡，其中一个泡泡跑到一个泡小妹说，小妹小妹你过来咱俩比比谁大，小妹说哇你好大，于是他跑到了泡小妹前面，又跟前面的一个泡大哥说，大哥，咱俩比比谁大呗。泡大哥看了他一眼他就老实了。这就是内层的for，那个泡泡跟每个人都比一次。

话说那个泡泡刚老实下来，另一个泡泡又开始跟别人比谁大了，这就是外层的for，每个泡泡都会做一次跟其他泡泡比个没完的事。

2. 实现逻辑

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

第一个循环（外循环），负责把需要冒泡的那个数字排除在外；
第二个循环（内循环），负责两两比较交换。

3. 动图演示bubble_sort

4. 性能分析

• 平均时间复杂度：O(N^2)
• 最佳时间复杂度：O(N)
• 最差时间复杂度：O(N^2)
• 空间复杂度：O(1)
• 排序方式：In-place
• 稳定性：稳定

解析说明：
冒泡排序涉及相邻两两数据的比较，故需要嵌套两层 for 循环来控制。
外层循环 n 次，内层最多时循环 n – 1次、最少循环 0 次，平均循环(n-1)/2；
所以循环体内总的比较交换次数为：n*(n-1) / 2 = (n^2-n)/2
按照计算时间复杂度的规则，去掉常数、去掉最高项系数，其复杂度为O(N^2)
最优的空间复杂度为开始元素已排序，则空间复杂度为 0；
最差的空间复杂度为开始元素为逆排序，则空间复杂度为 O(N);
平均的空间复杂度为O(1)

注：

• n：数据规模
• k：”桶”的个数
• In-place：占用常数内存，不占用额外内存
• Out-place：占用额外内存

5. 代码实现（C++版）

// 冒泡排序
void bubble_sort(int arr[], int len)  
{  
    int i, j;  
    for (i = 0; i < len; i++)  
        for (j = 1; j < len - i; j++)  
            if (arr[j - 1] > arr[j])  
                swap(arr[j - 1], arr[j]);  
}

6. 优化改进

6.1 改进方法①
场景一：
在某次遍历中如果没有数据交换，说明整个数组已经有序。若初始序列就是排序好的，如果用基础的冒泡排序方法，仍然还要比较O(N^2)次，但无交换次数。

改进思路：
通过设置标志位来记录此次遍历有无数据交换，进而可以判断是否要继续循环，设置一个flag标记，当在一趟序列中没有发生交换，则该序列已排序好，但优化后排序的时间复杂度没有发生量级的改变。

改进代码（C++版）：

// 冒泡排序改进
void bubble_sort(int arr[], int len)
{
    for (int i = 0; i < len-1; i++){        //比较n-1次
        bool exchange = true;               //冒泡的改进，若在一趟中没有发生逆序，则该序列已有序
        for (int j = len-1; j >i; j--){     //每次从后边冒出一个最小值
            if (arr[j] < arr[j - 1]){       //发生逆序，则交换
                swap(arr[j], arr[j - 1]);
                exchange = false;
            }
        }
        if (exchange){
            return;
        }
    }
}

6.2 改进方法②
场景二：
如果有100个数的数组，仅前面10个无序，后面90个都已排好序且都大于前面10个数字，那么在第一趟遍历后，最后发生交换的位置必定小于10，且这个位置之后的数据必定已经有序了。

改进思路：
记录某次遍历时最后发生数据交换的位置pos，这个位置之后的数据显然已经有序了。因此通过记录最后发生数据交换的位置就可以确定下次循环的范围了。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。

改进代码（C++版）：

// 冒泡排序改进② 
void bubble_sort(int arr[], int len)  
{  
    int j, k;  
    int flag;  
    flag = len;  
    while (flag > 0)  
    {  
        k = flag;  
        flag = 0;  
        for (j = 1; j < k; j++)  
            if (arr[j - 1] > arr[j])  
            {  
                swap(arr[j - 1], arr[j]);  
                flag = j;  
            }  
    }  
}

7. 总结

冒泡排序毕竟是一种效率低下的排序方法，在数据规模很小时，可以采用。数据规模比较大时，建议采用其它排序方法。

---

四、插入排序（Insertion Sort）

插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。打过扑克牌的应该都会明白（当然，如果你说你打扑克牌摸牌的时候从来不按牌的大小整理牌，那我只能呵呵了）

1. 基本思想

插入排序的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

趣味解释：

插入排序操作类似于摸牌并将其从大到小排列。每次摸到一张牌后，根据其点数插入到确切位置。

如上图：表示的是摸到草花7后进行插入的过程。忽略最右边的草花10，相当于一开始7在最右边，然后逐个与左边的排相比较(当然左边的牌早已排好顺序)，将其放置在合适的位置。当摸到草花10后重复上述过程即可。

而实际中，如何将插入牌的这个过程应用到实际排序操作中呢？具体我们以一组数字来说操作说明：

例如我们有一组数字：｛5，2，4，6，1，3｝，我们要将这组数字从小到大进行排列。 我们从第二个数字开始，将其认为是新增加的数字，这样第二个数字只需与其左边的第一个数字比较后排好序；在第三个数字，认为前两个已经排好序的数字为手里整理好的牌，那么只需将第三个数字与前两个数字比较即可；以此类推，直到最后一个数字与前面的所有数字比较结束，插入排序完成。

2. 实现逻辑

① 从第一个元素开始，该元素可以认为已经被排序

② 取出下一个元素，在已经排序的元素序列中从后向前扫描

③ 如果该元素（已排序）大于新元素，将该元素移到下一位置

④ 重复步骤③，直到找到已排序的元素小于或者等于新元素的位置

⑤ 将新元素插入到该位置后

⑥ 重复步骤②~⑤

3. 动图演示

4. 性能分析

• 平均时间复杂度：O(N^2)
• 最差时间复杂度：O(N^2)
• 空间复杂度：O(1)
• 排序方式：In-place
• 稳定性：稳定

如果插入排序的目标是把n个元素的序列升序排列，那么采用插入排序存在最好情况和最坏情况：

(1) 最好情况：序列已经是升序排列，在这种情况下，需要进行的比较操作需(n-1)次即可。

(2) 最坏情况：序列是降序排列，那么此时需要进行的比较共有n(n-1)/2次。

• 插入排序的赋值操作是比较操作的次数减去(n-1)次。平均来说插入排序算法复杂度为O(N^2)。
• 最优的空间复杂度为开始元素已排序，则空间复杂度为 0；
• 最差的空间复杂度为开始元素为逆排序，则空间复杂度最坏时为 O(N);
• 平均的空间复杂度为O(1)

注：
n：数据规模
k：”桶”的个数
In-place：占用常数内存，不占用额外内存
Out-place：占用额外内存

5. 代码实现（C++版）

// 插入排序
void InsertSort(int arr[], int len){
	// 检查数据合法性
	if(arr == NULL || len <= 0){
	    return;
	}
	for(int i = 1; i < len; i++){
	    int tmp = arr[i];
		int j;
		for(j = i-1; j >= 0; j--){
			//如果比tmp大把值往后移动一位
			if(arr[j] > tmp){
			   arr[j+1] = arr[j];
			}
			else{
			   break;
			}
		}
		arr[j+1] = tmp;
	}	
}

6. 算法优化改进

6.1 改进方法①
场景分析：
直接插入排序每次往前插入时，是按顺序依次往前查找，数据量较大时，必然比较耗时，效率低。

改进思路：
在往前找合适的插入位置时采用二分查找的方式，即折半插入。

二分插入排序相对直接插入排序而言：平均性能更快，时间复杂度降至O(NlogN)，排序是稳定的，但排序的比较次数与初始序列无关，相比直接插入排序，在速度上有一定提升。逻辑步骤：

• ① 从第一个元素开始，该元素可以认为已经被排序
• ② 取出下一个元素，在已经排序的元素序列中二分查找到第一个比它大的数的位置
• ③将新元素插入到该位置后
• ④ 重复上述两步

改进代码（C++版）：
 

// 插入排序改进：二分插入排序
void BinaryInsertSort(int arr[], int len)   
{   
    int key, left, right, middle;   
    for (int i=1; i<len; i++)   
    {   
        key = a[i];   
        left = 0;   
        right = i-1;   
        while (left<=right)   
        {   
            middle = (left+right)/2;   
            if (a[middle]>key)   
                right = middle-1;   
            else   
				left = middle+1;   
        }   
                   
        for(int j=i-1; j>=left; j--)   
        {   
            a[j+1] = a[j];   
        }   
                   
        a[left] = key;          
    }   
}

6.2 改进方法②

场景分析：
(1) 插入排序对几乎已排好序的数据操作时，效率很高，可以达到线性排序的效率。
(2) 插入排序在每次往前插入时只能将数据移动一位，效率比较低。

改进思路：
先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。

改进思路二的方法实际上就是希尔排序。在这里只给出思路，在后续系列 希尔排序 中再做具体讲解说明。

7. 总结

插入排序不适合对于数据量比较大的排序应用。但是，如果需要排序的数据量很小，例如，量级小于千，那么插入排序还是一个不错的选择。尤其当数据基本