深度剖析八大经典排序算法—C++实现（通俗易懂版）

内容会持续更新，有错误的地方欢迎指正，谢谢!

引言

需握各种排序和常用的数据结构的核心思想，并知道是以什么样的方式解决了什么样的问题。

该博客的示例代码均以递增排序为目的~
学习建议：切忌看示例代码去理解算法，而是理解算法原理写出代码，否则会很快就会忘记。

//排序原始数组：
int a[10]= { 7,5,3,4,4,1,9,45,121,3 };

算法分类

八大经典排序算法分类：

1. 交换类排序（冒泡排序、快速排序）
2. 插入类排序（简单插入排序、希尔排序）
3. 选择类排序（简单选择排序、堆排序）
4. 归并排序
5. 计数排序

总结：
所需辅助空间最多：归并排序
平均速度最快：快速排序
不稳定：快速排序，希尔排序，简单选择排序，堆排序

数据初始排序状态对堆排序不会产生太大的影响，而快速排序却恰恰相反。还有基数排序、桶排序可以了解一下。

算法的实现

非线性时间比较类排序

交换类排序

一、最基础的排序—冒泡排序

原理：

1. 比较相邻的两个数的大小，将最大的数放在右边，计数器i++；
2. 继续重复操作1，直到a[n-2]和a[n-1]比较结束，数组a中最大的值已在a[n-1]；
3. 将进行排序的数组长度n减1，重复操作1和操作2，直到n为1，排序完毕。

复杂度：

平均时间复杂度：O(n^2)

最好的情况：如果待排序数据序列为正序，则一趟冒泡就可完成排序，排序的比较次数为n-1次，且没有移动，时间复杂度为O(n)。要实现O(n)的复杂度，代码里需要加一个标志位（Bool变量）。

最坏的情况：如果待排序数据序列为逆序，则冒泡排序需要n-1次趟，每趟进行n-i次排序的比较和移动，即比较和移动次数均达到最大值：比较次数=n(n−1)/2=O(n^2)，移动次数等于比较次数，因此最坏时间复杂度为O(n^2)。

稳定性：

稳定排序（稳定性和不稳定性指：相同元素的前后顺序没变或变了）

代码：

void BubbleSort(int* array, int length)
{
    for (int i = 0; i < length - 1; ++i)
    {
        //bool is_Swap=false;
        for (int j = 0; j < length - 1 - i; ++j)
        {
            if (array[j] > array[j + 1])
            {
                //is_Swap=true;
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
                /*
                交换还可使用如下方式
                a = a + b;
                b = a - b;
                a = a - b;
                交换还可使用如下方式
                a=a^b;
                b=b^a;
                a=a^b;
                */
            }
        }
        //if(is_Swap==false)
            //return;
    }
}

二、最快的排序—快速排序

在交换类排序算法中，快排是速度最快的。采用分治的思想。

原理：

1. 从n个元素中选择一个元素作为分区的标准，一般选第一个元素；
2. 把小于该元素的放在左边，把大于等于该元素的放在右边，中间就放该元素；
3. 再分别对左右子序列重复操作1和2，直到每个子序列里只有一个元素，排序完毕。

复杂度：

平均时间复杂度：O(n*log n)。原因：快排是将数组一分为二到底，所以需要O(log n)次此操作，每次操作需要排序n次，所以，大多数情况下，时间复杂度都是O(n*log n)。

最好的情况：是每趟排序结束后，每次划分使两个子文件的长度大致相等，时间复杂度为O（n*log n）。

最坏的情况：是待排序元素已经排好序。第一趟经过n-1次比较后第一个元素保持位置不变，并得到一个n-1个元素的子序列；第二趟经过n-2次比较，将第二个元素定位在原来的位置上，并得到一个包括n-2个元素的子序列，依次类推，这样总的比较次数是：n(n-1)/2=O(n^2)。

稳定性：

不稳定排序

代码：

第一种快速排序：一个“指针”从左往右，一个“指针”从右往左

void QuickSort(int* array,int low,int high) 
{
    if (low >= high)
        return;
    int left = low;
    int right = high;
    int key = array[left];//选择第一个元素作为区分元素，当然也可以选最后一个元素。
    while (left != right)
    {
        while (left != right&&array[right] >= key)//从右往左，把小于key的元素放到key的左边
            --right;
        array[left] = array[right];
        while (left != right&&array[left] <= key)//从左往右，把大于key的元素放到key的右边
            ++left;
        array[right] = array[left];
    }
    array[left] = key;//此时left等于right

    //一分为二，分治思想，递归调用。
    QuickSort(array