面试中常考排序算法总结（不看后悔）

面试中常见的排序算法（C++版）

 
前置基础知识：

• 稳定：a=b且a在b前面，排序之后a仍然在b的前面
• 不稳定：a=b且a在b前面，排序之后 a 可能会出现在 b 的后面
• 时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现的规律
• 空间复杂度：算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数

 
1、冒泡排序
原理：

1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
3. 针对所有的元素重复以上的步骤，除了最后一个；
4. 重复步骤1~3，直到排序完成。

ps：n 个数排序需要 n-1 趟，第 i 趟需要比较 n-i 次

void bubbleSort(vector<int> &vec,int size)
{
    for (int i = 0; i < size - 1; i++)
    {
        for (int j = 0; j < size - 1 -i; j++)
        {
            if (vec[j] > vec[j + 1]) swap(vec[j], vec[j + 1]);
        }
    }
}

 
冒泡排序分析：
（1）时间复杂度
最好情况:只需进行一次冒泡操作，没有任何元素交换，此时就可以结束程序，时间复杂度是O(n)

最坏情况: 要排序的数据完全倒序排列的，需要进行n次冒泡操作，每次冒泡时间复杂度为O(n)，时间复杂度为O(n^2)

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

（2）是否原地排序
冒泡过程只涉及相邻数据之间的交换操作没有额外内存消耗，故冒泡排序为原地排序算法

（3）稳定性
在冒泡排序的过程中，只有每一次冒泡操作才会交换两个元素的顺序。为了冒泡排序的稳定性，在元素相等时，不予交换，此时冒泡排序为稳定的排序算法
 

2、选择排序
原理：先在未排序序列中找到最小（大）元素，放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕

void selectSort(vector<int> &vec,int size)
{
    for (int i = 0; i < size - 1; i++)
    {
        int minIndex = i;
        for (int j = i+1; j < size; j++)
        {
            if (vec[j] < vec[minIndex]) minIndex = j;
        }
        swap(vec[minIndex], vec[i]);
    }
}

 
选择排序分析：
（1）时间复杂度
最好情况，最坏情况：都需要遍历未排序区间，找到最小元素。所以都为O(n^2），所以平均复杂度是 O(n ^2)

（2）是否原地排序
没有额外的内存消耗，为原地排序算法

（3）稳定性
不稳定，每次都要在未排序区间找到最小的值和前面的元素进行交换，这样如果遇到相同的元素，他们的顺序会发生变化
 

3、插入排序
原理：一个数时相当于有序了，因此从第二个数开始向后遍历，每次都与前面已经排好序的数组中每个数比较，插入合适的位置，使得前面已经排好序的仍然保持有序

void insertSort(vector<int>& vec, int size)  
{
    for (int i = 1; i < size; i++)
    {
        int num = vec[i],j = i-1; //num是待插入的数 j是已排序的区间端点 当只有1个数时相当于是有序的
        while(j >= 0 && num < vec[j])
        {
            vec[j + 1] = vec[j]; //元素向后移动
            j--;
        }
        vec[j + 1] = num; //while循环结束时说明当前的vec[j]已经与num相等或者小于num，此时num应该插入这个数的后面，即 j+1 的位置
    }
}

 
插入排序分析：
（1）时间复杂度
最好情况: 即该数据已经有序，不需要移动任何元素。只要从头到尾遍历整个数组中的元素O(n)

最坏情况: 即数组中的元素刚好是倒序的，每次插入时都需要和已排序区间中所有元素进行比较，并移动元素。因此最坏情况下的时间复杂度是O(n^2)

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

（2）是否原地排序
在排序过程中并不需要额外的内存消耗，插入排序是一个原地排序算法

（3）稳定性
在插入的过程中，如果遇到相同的元素，可以选择将其插入到之前元素的前面也可以选择插入到后面。所以，插入排序可以是稳定的也可以是不稳定的
 

4、快速排序
原理：简称“快排”，主要利用的分治思想。具体做法是在数组中取一个基准值 pivot，pivot 位置可以随机选择。选择完 pivot 之后，将小于 pivot 的所有元素放在 pivot 左边，将大于 pivot 的所有元素放在右边。最终，pivot 左侧元素都将小于右侧元素。接然后利用递归将左侧的子数组和右侧子数组进行同样的快速排序。最后左右两侧的数组都是有序的，那么整个数组就有序了

void quickSort(vector<int> &vec, int l, int r)
{
    if (l >= r) return;
    int i = l - 1, j = r + 1, x = vec[l + r >> 1]; //x是基准数
    while (i < j)
    {
        do i++; while (vec[i] < x);      //找当前左侧数中比基准数大的第一个数
        do j--; while (vec[j] > x);      //找当前右侧数中比基准数小的第一个数
        if (i < j) swap(vec[i], vec[j]); //交换位置 使得基准数左边的数都比基准数小，右边的数都比基准数大
    }
    quickSort(vec, l, j);                //对基准数左右两侧的数组依次进行上述过程     
    quickSort(vec, j + 1, r);
}

 
快速排序分析：
（1）时间复杂度
最好情况：如果每次分区都刚好把数组分成两个大小一样的区间，那么时间复杂度为O(nlogn)（递归树的深度为log(n)）

最坏情况：待排序的序列为正序或者逆序，每次划分只得到一个比上一次划分少一个记录的子序列，而另一个为空。此时递归树是一棵斜树（递归树深度是n），算法退化成O(n^2)

平均复杂度：O(nlogn)

（2）空间复杂度
快排涉及递归的栈空间使用，最好情况空间复杂度为O(logn)，最坏情况下递归树退化成一条链，空间复杂度为O(n)

（3）是否原地排序
快速排序也没有申请额外的内存空间，是一种原地排序算法

（4）稳定性
不稳定，快排的分区操作涉及元素的位置交换，快速排序不是一个稳定的排序算法
 

5、归并排序
原理：利用分治思想，先把数组按照中间索引一分为二，然后分别把左右数组排好序，再将排好序的左右两个数组按顺序合并成一个新数组，最后整个数组就是有序的了

void mergeSort(vector<int> &vec,int l,int r)
{
    if (l >= r) return;        //区间只有一个数的时候停止递归
    int mid = l + r >> 1;      //划分区间
    mergeSort(vec,l,mid);      //递归划分左右区间
    mergeSort(vec,mid+1,r);
    vector<int> temp;
    int i = l, j = mid+1, k = 0;  //i为左区间的指针，j为右区间的指针，k为排序后的数的索引，temp数组用于合并区间时临时存储排好序的数
    //左右两区间的数比较，小的或者相等的数将左区间的数放入temp，否则右区间放入
    while (i <= mid && j <= r)
    {
        if (vec[i] <= vec[j]) temp.push_back(vec[i++]);
        else 
            temp.push_back(vec[j++]);
    }
    // 存在还没比较完就有一个区间已经没有数了的情况，需要将剩余的数都存入temp，以下while只有一个会执行
    while(i <= mid) temp.push_back(vec[i++]);
    while(j <= r) temp.push_back(vec[j++]);
    i = l;
    for (auto x : temp) vec[i++] = x;  //将排好序的数组存入vec
}

 
归并排序分析：
（1）时间复杂度
对 n 个元素递归排序所需时间复杂度，等于左右子区间 n/2 个元素分别递归排序的时间，加上将两个已排好的子区间合并起来的时间O(n)。计算得知其时间复杂度为O(nlogn)

（2）空间复杂度
归并排序过程中需要分配临时数组 temp，空间复杂度为O(n)

（3）是否原地排序
有额外的内存空间使用，不是原地排序算法

（4）稳定性
稳定，当排序过程中遇到左右数组中的元素相等时，可以先把左边的元素先放入 temp 数组，再放入右边的元素到 temp 数组，这就保证了排序后相等元素的前后顺序不改变。因此，归并排序是稳定的排序算法