十大排序算法（Top 10 Sorting Algorithms）

果冻同学

已于 2022-07-05 19:45:10 修改

阅读量1w

点赞数 19

分类专栏： # 数据结构与算法文章标签：排序算法算法数据结构

于 2022-07-05 19:42:19 首次发布

本文链接：https://blog.csdn.net/wd_dut/article/details/125626597

版权

数据结构与算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

0. 排序算法概述

十种常见排序算法可以分为两大类：

比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。
非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。

1. 选择排序（Selection Sort）

基本思想：

首先找到数组中最小的那个元素，将它和数组的第一个元素交换位置。然后在剩下的元素中找到最小的元素，将它与数组的第二个元素交换位置。如此往复，直到将整个数组排序。

代码实现：

// 两数交换
void mySwap(int &a, int &b) {
    int tmp = a;
    a = b;
    b = tmp;
}

// 选择排序
void SelectionSort(vector<int> &num) {
	int len = num.size();
    for (int i = 0; i < len - 1; ++i) {
        int minPos = i;
        for (int j = i + 1; j < len; ++j) {
            if (num[j] < num[minPos])
                minPos = j;
        }
        
        mySwap(num[i], num[minPos]);
    }
}

算法分析：

时间复杂度： $O(n^2)$
空间复杂度： $O (1)$
稳定性：不稳定排序

2. 直接插入排序（Insertion Sort）

基本思想：

把第一个元素作为有序部分，从第二个元素开始将剩余元素逐个插入有序部分的合适位置，最终得到排序的序列。

代码实现：

// 直接插入排序
void InsertionSort(vector<int> &num) {
    int len = num.size();
    for (int i = 1; i < len; ++i) {
        int tmp = num[i];
        int j = i - 1;
        while (j >= 0 && num[j] > tmp) {
            num[j + 1] = num[j];
            --j;
        }

        num[j + 1] = tmp;
    }
}

算法分析：

时间复杂度： $O(n^2)$
空间复杂度： $O (1)$
稳定性：稳定排序

3. 冒泡排序（Bubble Sort）

基本思想：

把第一个元素与第二个元素比较，如果第一个比第二个大，则交换他们的位置。接着继续比较第二个与第三个元素，如果第二个比第三个大，则交换他们的位置……对每一对相邻元素执行同样操作，一趟比较完成后，排在最右的元素便是最大的数。除去最右的元素，对剩余的元素做同样的工作，最终得到排序序列。

代码实现：

// 冒泡排序
void BubbleSort(vector<int> &num) {
    int len = num.size();
    for (int i = 0; i < len; ++i) {
        for (int j = 0; j < len - i - 1; ++j) {
            if (num[j + 1] < num[j])
                mySwap(num[j + 1], num[j]);
        }
    }
}

算法分析：

时间复杂度： $O(n^2)$
空间复杂度： $O (1)$
稳定性：稳定排序

算法优化：

假如从开始的第一对到结尾的最后一对，相邻的元素之间都没有发生交换的操作，这意味着右边的元素总是大于等于左边的元素，此时的数组已经是有序的了，无需再对剩余的元素重复比较下去了。

// 冒泡排序优化
void BubbleSortPlus(vector<int> &num) {
    int len = num.size();
    for (int i = 0; i < len; ++i) {
        bool flag = true;
        for (int j = 0; j < len - i - 1; ++j) {
            if (num[j + 1] < num[j]) {
                mySwap(num[j + 1], num[j]);
                flag = false;
            }
        }
        if (flag)
            break;
    }
}

4. 希尔排序（Shell Sort）

基本思想：

希尔排序可以说是插入排序的一种变种。无论是插入排序还是冒泡排序，如果数组的最大值刚好是在第一位，要将它挪到正确的位置就需要 n - 1 次移动。也就是说，原数组的一个元素如果距离它正确的位置很远的话，则需要与相邻元素交换很多次才能到达正确的位置，这样是相对比较花时间了。

希尔排序就是为了加快速度简单地改进了插入排序，交换不相邻的元素以对数组的局部进行排序。先让数组中任意间隔为 h 的元素有序，刚开始 h 的大小可以是 h = n / 2,接着让 h = n / 4，让 h 一直缩小，当 h = 1 时，也就是此时数组中任意间隔为1的元素有序，此时的数组就是有序的了。

代码实现：

// 希尔排序
void ShellSort(vector<int> &num) {
    int len = num.size();

    // 逐渐缩小间隔，最终为1
    for (int step = len / 2; step > 0; step /= 2) {   
        for (int i = step; i < len; ++i) {
            int tmp = num[i];
            int j = i - step;
            while (j >= 0 && tmp < num[j]) {
                num[j + step] = num[j];
                j -= step;
            }
            num[j + step] = tmp;
        }
    }
}

算法分析：

时间复杂度： $O(n^2)$
空间复杂度： $O (1)$
稳定性：不稳定排序

5. 归并排序（Merge Sort）

基本思想：

归并排序是建立在归并操作上的一种有效的排序算法。该算法是分治法（Divide and Conquer）的典型应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

根据具体的实现，归并排序包括"从上往下"和"从下往上"2种方式。

从下往上（循环）：将待排序的数列分成若干个长度为1的子数列，然后将这些数列两两合并；得到若干个长度为2的有序数列，再将这些数列两两合并；得到若干个长度为4的有序数列，再将它们两两合并；直到合并成一个数列为止。这样就得到了最终的排序结果。
从上往下（递归）：它基本包括3步：
- 分解：将当前区间一分为二，即求分裂点 mid = (low + high) / 2；
- 求解：递归地对两个子区间 [low…mid] 和 [mid+1…high] 进行归并排序。递归的终结条件是子区间长度为1；
- 合并：将已排序的两个子区间 [low…mid] 和 [mid+1…high] 归并为一个有序的区间 [low…high]。

5.1 非递归（循环）式归并

代码实现：

// 合并两个有序数组
void Merge(vector<int> &num, int left, int mid, int right) {
    vector<int> leftSubArray(num.begin() + left, num.begin() + mid + 1);
    vector<int> rightSubArray(num.begin() + mid + 1, num.begin() + right + 1);

    int idxLeft = 0, idxRight = 0;
    // 在数组最后插入int类型能表示的最大值
    leftSubArray.insert(leftSubArray.end(), numeric_limits<int>::max());
    rightSubArray.insert(rightSubArray.end(), numeric_limits<int>::max());
   
    // 已有元素不可能大于int能表示的最大值，因此能覆盖两个数组中的所有元素
    for (int i = left; i <= right; i++) {
        if (leftSubArray[idxLeft] < rightSubArray[idxRight]) {
            num[i] = leftSubArray[idxLeft];
            idxLeft++;
        } else {
            num[i] = rightSubArray[idxRight];
            idxRight++;
        }
    }
}

// 归并排序——非递归
void MergeSortLoop(vector<int> &num) {
    int len = num.size();
    // 子数组的大小分别为1，2，4，8...
    for (int i = 1; i < len; i += i) {
        // 进行数组划分
        int left = 0;
        int mid = left + i - 1;
        int right = mid + i;
        // 将数组大小为 i 的数组两两合并
        while (right < len) {
            Merge(num, left, mid, right);
            left = right + 1;
            mid = left + i - 1;
            right = mid + i;
        }
        // 还有一些被遗漏的数组没合并，因为不可能每个子数组的大小都刚好为 i
        if (left < len && mid < len) {
            Merge(num, left, mid, len - 1);
        }
    }
}

5.2 递归式归并

代码实现：

// 归并排序——递归
void MergeSortRecursion(vector<int> &num, int left, int right) {
    if (left >= right)
        return;
    
    int mid = (right - left) / 2 + left;
    MergeSortRecursion(num, left, mid);
    MergeSortRecursion(num, mid + 1, right);
    Merge(num, left, mid, right);
}

算法分析：

时间复杂度： $O (n * l o g n)$
空间复杂度： $O (n)$
稳定性：稳定排序

6. 快速排序（Quick Sort）

基本思想：

从数组中选择一个元素，称为中轴元素。把数组中所有小于中轴元素的元素放在其左边，所有大于或等于中轴元素的元素放在其右边，显然，此时中轴元素所处的位置的是有序的。也就是说，我们无需再移动中轴元素的位置。

以中轴元素为界把大的数组切割成两个小的数组（分割操作，partition），且两个数组都不包含中轴元素。对中轴元素左右两边的数组进行递归操作，直到数组的大小为1。此时每个元素都处于有序的位置。

代码实现：

// 分割操作
int Partition(vector<int> &num, int left, int right) {
    int pivot = num[left];
    int i = left + 1, j = right;
   
    while (true) {
        // 向右找到第一个小于等于 pivot 的元素位置
        while (i <= j && num[i] <= pivot) 
            ++i;
        // 向左找到第一个大于等于 pivot 的元素位置
        while(i <= j && num[j] >= pivot ) 
            --j;
        
        if(i >= j)
            break;

        // 交换两个元素的位置，使得左边的元素不大于pivot,右边的不小于pivot
        mySwap(num[i], num[j]);
    }
    // 使中轴元素处于有序的位置
    num[left] = num[j];  
    num[j] = pivot;
    
    return j;
}

// 另一种分割操作，参考《剑指Offer2》
int Partition2(vector<int> &num, int left, int right) {
    // 快排时间复杂度与中轴元素的选择有关
    int index = RandomInRange(left, right);
    // 随机选择中轴元素
    mySwap(num[index], num[end]);
    
    int small = left - 1;
    for (int i = left; i < right; ++i) {
        if (num[i] < num[right]) {
            ++small;
            if (small != i)
                mySwap(num[i], num[small]);
        }
    }

    ++small;
    mySwap(num[small], num[right]);

    return small;
}

// 快速排序
void QuickSort(vector<int> &num, int left, int right) {
    if (left < right) {
        // 获取中轴元素所处的位置并进行分割
        int mid = Partition(num, left, right);
        
        // 递归处理
        QuickSort(num, left, mid - 1);
        QuickSort(num, mid + 1, right);
    }
}

算法分析：

时间复杂度： $O (n * l o g n)$
空间复杂度： $O (l o g n)$
稳定性：不稳定排序

7. 堆排序（Heap Sort）

基本思想：

堆的特点就是堆顶的元素是一个最值，大顶堆的堆顶是最大值，小顶堆则是最小值。

堆排序就是把堆顶的元素与最后一个元素交换，交换之后破坏了堆的特性，我们再把堆中剩余的元素再次构成一个大顶堆，然后再把堆顶元素与最后第二个元素交换….如此往复下去，等到剩余的元素只有一个的时候，此时的数组就是有序的了。

代码实现：

// 下沉操作
void downAdjust(vector<int> &num, int parent, int n) {  
    // 临时保存要下沉的元素  
    int temp = num[parent];      
    // 定位左孩子节点的位置
    int child = 2 * parent + 1;    
    
    // 开始下沉
    while (child <= n) {
        // 如果右孩子节点比左孩子大，则定位到右孩子
        if (child + 1 <= n && num[child] < num[child + 1])
            ++child;
        
        // 如果孩子节点小于或等于父节点，则下沉结束
        if (num[child] <= temp) 
            break;
        
        // 父节点进行下沉
        num[parent] = num[child];
        parent = child;
        child = 2 * parent + 1;
    }
    num[parent] = temp;
}

// 堆排序
void HeapSort(vector<int> &num) {
    int len = num.size();
    
    // 构建大顶堆
    for (int i = (len - 2) / 2; i >= 0; --i) {
        downAdjust(num, i, len - 1);
    }
    
    // 进行堆排序
    for (int i = len - 1; i >= 1; --i) {
        // 把堆顶元素与最后一个元素交换
        mySwap(num[0], num[i]);
        // 把打乱的堆进行调整，恢复堆的特性
        downAdjust(num, 0, i - 1);
    }
}

算法分析：

时间复杂度： $O (n * l o g n)$
空间复杂度： $O (1)$
稳定性：不稳定排序

8. 计数排序（Counting Sort）

基本思想：

计数排序适合于最大值和最小值的差值不是很大的情况。

把数组元素作为数组的下标，然后用一个临时数组统计该元素出现的次数，例如 temp[i] = m, 表示元素 i 一共出现了 m 次。最后再把临时数组统计的数据从小到大汇总起来，此时汇总起来是数据是有序的。

代码实现：

// 计数排序
void CountingSort(vector<int> &num) { 
    int len = num.size();
    
    // 得到数列的最大和最小值
    int max = num[0], min = num[0];  
    for (int i = 1; i < len; ++i) {        
        if(num[i] > max)           
            max = num[i];        
        
        if (num[i] < min)
            min = num[i];
    }
    
    // 根据数列最大值确定统计数组的长度
    vector<int> countArray(max - min + 1, 0);
    
    // 遍历数列，填充统计数组
    for (int i = 0; i < len; ++i) {
        countArray[num[i] - min]++;
    }
    
    // 遍历统计数组，输出结果   
    int index = 0;  
    for (int i = 0; i < countArray.size(); ++i) {
        for (int j = 0; j < countArray[i]; ++j) {
            num[index++] = i + min;
        }
    }  
}

算法分析：

时间复杂度： $O (n + k)$ ，其中k为临时数组大小
空间复杂度： $O (k)$
稳定性：稳定排序

9. 桶排序（Bucket Sort）

基本思想：

桶排序就是把最大值和最小值之间的数进行瓜分，例如分成 10 个区间，10个区间对应10个桶，我们把各元素放到对应区间的桶中去，再对每个桶中的数进行排序，可以采用归并排序、快速排序等方法。之后每个桶里面的数据就是有序的了，按顺序遍历各桶即可得到排序序列。桶排序也可用于浮点数排序。

代码实现：

// 桶排序
// 有负数的话需要进行预处理，本函数包含预处理部分
void BucketSort(vector<int> &num) {   
    int len = num.size();
    
    // 得到数列的最大最小值
    int max = num[0], min = num[0];  
    for(int i = 1; i < len; ++i) {        
        if(num[i] > max)           
            max = num[i];        
        
        if (num[i] < min)
            min = num[i];
    }
    
    // 计算桶的数量并初始化
    int bucketNum = (max - min) / len + 1;
    vector<int> vec;
    vector<vector<int>> bucket;
    for (int i = 0; i < bucketNum; ++i)
        bucket.push_back(vec);
    
    // 将每个元素放入桶
    for (int i = 0; i < len; ++i) {
        // 减去最小值，处理后均为非负数
        int pos = (num[i] - min) / len;
        bucket[pos].push_back(num[i]);
    }
    
    // 对每个桶进行排序，此处可选择不同排序方法
    for (int i = 0; i < bucket.size(); ++i) 
        sort(bucket[i].begin(), bucket[i].end());
    
    // 将桶中的元素赋值到原序列
	int index = 0;
	for (int i = 0; i < bucketNum; ++i)
		for(int j = 0; j < bucket[i].size(); ++j)
			num[index++] = bucket[i][j];
}

算法分析：

时间复杂度： $O (n + k)$
空间复杂度： $O (k)$
稳定性：稳定排序

10. 基数排序（Radix Sort）

基本思想：

先以个位数的大小来对数据进行排序，接着以十位数的大小来多数进行排序，接着以百位数的大小……

排到最后，就是一组有序的元素了。在以某位数进行排序的时候，是用“桶”来排序的。

由于某位数（个位/十位….，不是一整个数）的大小范围为0~9，所以我们需要10个桶，然后把具有相同数值的数放进同一个桶里，之后再把桶里的数按照0号桶到9号桶的顺序取出来。一趟下来按照某位数的排序就完成了。

代码实现：

// 基数排序
// 有负数的话需要进行预处理，本函数不包含预处理部分
void RadixSort(vector<int> &num) {
    int len = num.size();
    
    // 得到数列的最大值
    int max = num[0];  
    for (int i = 1; i < len; ++i) {        
        if(num[i] > max)           
            max = num[i];
    }

    // 计算最大值是几位数
    int times = 1;
    while (max / 10 > 0) {
        ++times;
        max /= 10;
    }

     // 创建10个桶
    vector<int> vec;
    vector<vector<int>> bucket;
    for (int i = 0; i < 10; ++i) {
        bucket.push_back(vec);
    }
    
    // 进行每一趟的排序，从个位数开始排
    for (int i = 1; i <= times; i++) {
        for (int j = 0; j < len; j++) {
            // 获取每个数最后第 i 位对应桶的位置
            int radio = (num[j] / (int)pow(10,i-1)) % 10;
            // 放进对应的桶里
            bucket[radio].push_back(num[j]);
        }
        // 合并放回原数组
        int k = 0;
        for (int j = 0; j < 10; j++) {
            for (int& t : bucket[j]) {
                num[k++] = t;
            }
            //合并之后清空桶
            bucket[j].clear();
        }  
    }
}