十大排序算法复杂度及稳定性分析和c++实现

最新推荐文章于 2023-09-12 19:51:01 发布
最新推荐文章于 2023-09-12 19:51:01 发布
阅读量268 收藏 2
点赞数
分类专栏： 数据结构与算法 文章标签： 排序算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45673036/article/details/117531669
版权

排序

分类

在这里插入图片描述

按排序依据原则分类（普遍流行）：

在这里插入图片描述

各排序算法比较

在这里插入图片描述

插入排序

  • 基本思想：边插入边排序，保证子序列中随时都是排好序的。
  • 按插入位置方法的不同分类：1)顺序法：直接插入排序 2)二分法：折半插入排序 3)缩小增量：希尔排序
  1. 直接插入排序

原理：从第二位数据开始， 当前数（第一趟是第二位数）与前面的数依次比较，如果前面的数大于当前数，则将这个数放在当前数的位置上，当前数的下标-1，直到当前数不大于前面的某一个数为止，直到遍历至最后一位元素。

代码实现：

#include<iostream>
#include<vector>
using namespace std;

void InsertSort(vector<int>& nums){
    for (int i = 1; i < nums.size(); i++) {// 从第二位开始
        if (nums[i] < nums[i - 1]) {// 若第i个元素大于第i-1个元素，则直接插入。反之，需要移动有序表后插入
            int key = nums[i];// 设置哨兵
            int j;
            for (j = i - 1; key < nums[j]; j--) {//每次都和基准key比较，最小值往前插
                nums[j + 1] = nums[j];//后移
            }
            nums[j + 1] = key;// 插入到正确位置
        }
    }
}

int main() {
    vector<int> nums = {3, 5, 10, 16, 32, 23, 7, 4, 6};
    cout << "Before Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    InsertSort(nums);
    cout << "After Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}
  1. 折半插入排序

原理：采用二分法在直接插入排序基础上进行查找插入

代码实现：

#include<iostream>
#include<vector>
using namespace std;

void BinaryInsertSort(vector<int>& nums) {
    for (int i = 1; i < nums.size(); i++) {// 从第二位开始
        int key = nums[i];// 设置哨兵
        int low = 0, high = i - 1;
        while (low <= high) {
            int mid = low + (high - low) / 2;
            if (key < nums[mid]) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        for (int j = i - 1; j >= high + 1; j--) {
            nums[j + 1] = nums[j];// 后移
        }
        nums[high + 1] = key;// 插入到正确位置 
    }
}

int main() {
    vector<int> nums = {3, 5, 10, 16, 32, 23, 7, 4, 6};
    cout << "Before Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    BinaryInsertSort(nums);
    cout << "After Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}
  1. 希尔排序

原理：希尔排序是插入排序改良的算法，是插入排序的一种更高效的改进版本，也称递减增量排序，但是非稳定排序算法。希尔排序步长从大到小调整，先将整个待排序记录序列分割成为若干子序列，分别进行直接插入排序，待整个序列中的记录基本有序时，再对全体记录进行一次直接插入排序。所以步长是关键，最终步长为1，做最后的排序。

代码实现：

#include<iostream>
#include<vector>
using namespace std;

void ShellInsert(vector<int>& nums, int dk) {
    for (int i = dk; i < nums.size(); i++) {// 从增量步长开始
        int key = nums[i];// 设置哨兵
        int j;
        for (j = i - dk; key < nums[j]; j = j - dk) {
            nums[j + dk] = nums[j];// 后移
        }
        nums[j + dk] = key;// 插入到正确位置 
    }
}

void ShellSort(vector<int>& nums) {
	int dk = nums.size() / 2;// 步长
    while (dk >= 1) {
        ShellInsert(nums, dk);
        dk /= 2;
    }
}

int main() {
    vector<int> nums = {3, 5, 10, 16, 32, 23, 7, 4, 6};
    cout << "Before Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    ShellSort(nums);
    cout << "After Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}

交换排序

  • 基本思想：两两交换，如果发生逆序则交换，直到所有记录都排好序为止
  • 常见的交换排序方法：1) 冒泡排序 2)快速排序
  1. 冒泡排序

原理：每趟不断将记录两两比较，并按“前小后大”或者“前大后小”规则交换。具体的说就是重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。把最小的数浮上来，或者把最大的数据沉下去。

代码实现：

#include<iostream>
#include<vector>
using namespace std;

void bubbleSort(vector<int>& nums) {// 假设nums有n个元素
    for (int m = 1; m <= nums.size() - 1; m++) {// n个记录需要总共需要n - 1趟
        for (int j = 0; j < nums.size() - m; j++) {// 每趟需要比较n - m次
            if (nums[j] > nums[j + 1]) {
                swap(nums[j], nums[j + 1]);
                /*
                int temp = nums[j];
                nums[j] = nums[j + 1];
                nums[j + 1] = temp;
                */
            }
        }
    }
}

int main()
{
    vector<int> nums = {3, 5, 10, 16, 32, 23, 7, 4, 6};
    cout << "Before Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    bubbleSort(nums);
    cout << "After Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}
  1. 快速排序

原理：任取一个元素(第一个)为中心点，所有比它小的元素一律前放，比它大的元素一律后放，形成左右两个子数组，对各子数组重新选择中心元素并依此规则调整，直到每个子数组的元素只剩一个。

代码实现：

#include<iostream>
#include<vector>
using namespace std;

//partition为一趟排序 寻找中心点位置
int partition(vector<int>& nums, int low, int high) {
    int key = nums[low];// 先将下限第一个元素作为中心点设为哨兵
    while (low < high) {
        while (low < high && nums[high] >= key) high--;// 右边查找 比中心点大的元素一律后放
        nums[low] = nums[high];// 比中心点小的元素一律前放
        while (low < high && nums[low] <= key) low++;// 左边查找 比中心点小的元素一律前放
        nums[high] = nums[low];// 比中心点大的元素一律后放
    }
    nums[low] = key;// 中心点元素最后插入至中心点处
    return low;// 返回中心点位置
}

void quickSort(vector<int>& nums, int low, int high) {// 快速排序
    if (low >= high) return;
    int keyloc = partition(nums, low, high);//一次排序，找中心点位置，keyloc将数据分成左右两个子数组
    quickSort(nums, low, keyloc - 1);// 对低位左数组递归快排
    quickSort(nums, keyloc + 1, high);// 对高位右数组递归快排
}

int main()
{
    vector<int> nums = {3, 5, 10, 16, 32, 23, 7, 4, 6};
    cout << "Before Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    quickSort(nums, 0, nums.size() - 1);// 分别指向两端的数据
    cout << "After Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}

选择排序

  1. 简单选择排序

原理：在待排序的数据中选出最小(大)的元素放在其最终的位置。这里以从小到大排序为例，具体操作是首先通过n-1次比较，从n个数中找出最小数，将它和第一个元素交换，然后通过n-2次比较，从剩余n-1个数中找最小数，将它和第二个数交换，重复上述过程，共进行n-1趟排序，排序结束。

代码实现：

#include<iostream>
#include<vector>
using namespace std;

void selectSort(vector<int>& nums) {
    for (int i = 0; i < nums.size() - 1; i++) {// 趟数 n-1次比较
        int minIndex = i;// 记录最小索引
        for (int j = i + 1; j < nums.size(); j++) {// 每趟
            if (nums[j] < nums[minIndex]) {// 寻找最小值
                minIndex = j;// 记录最小值位置
            }
        }
        if (minIndex != i) { // 每趟遍历完发现最小值位置不在一开始记录的位置
            swap(nums[minIndex], nums[i]);// 交换最小值与一开始设置最小值的元素
            /*
            int temp = nums[minIndex];
            nums[minIndex] = nums[i];
            nums[i] = temp;
            */
        }
    }
}

int main()
{
    vector<int> nums = {3, 5, 10, 16, 32, 23, 7, 4, 6};
    cout << "Before Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    selectSort(nums);
    cout << "After Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}
  1. 堆排序

原理：分为两点，第一是堆排序，若在输出堆顶的最小值(最大值)后，使得剩余n-1个元素的序列重又建成一个堆，则得到n个元素的次小(大)值，如此反复，便能得到一个有序序列，这个过程称之为堆排序。第二是堆调整，以小根堆为例，输出堆顶元素之后，以堆中最后一个元素替代之，然后将根节点值与左右子树的根节点值进行比较，并与其中小者进行交换，重复上述步骤，直到叶子节点，将得到新的堆，称这个从堆顶到叶子的调整过程为“筛选”。

代码实现：

#include<iostream>
#include<vector>
using namespace std;

// 堆调整：（最大堆，有序区）。从堆顶把根卸出来放在有序区之前，再恢复堆。
void heapAdjust(vector<int>& nums, int start, int end){
    int dad = start, son = dad * 2 + 1;// 建立父节点下标和子节点下标 父节点下标从0开始
	while (son <= end) {// 若子节点在范围内才做比较
        if (son + 1 <= end && nums[son] < nums[son + 1]) son++;// 先比较两个子节点值，选择最大的
        if (nums[dad] > nums[son]) {// 如果父节点大于子节点代表调整完成，直接跳出函数
            return;
        } else {// 否则交换父子內容再继续子节点与孙节点比較
            swap(nums[dad], nums[son]);
            /*
            int temp = nums[dad];
            nums[dad] = nums[son];
            nums[son] = temp;
            */
            dad = son;
            son = dad * 2 + 1;
        }
    }
}

// 堆排序
void heapSort(vector<int>& nums){
    // 初始建堆,从最后一个非叶子节点(父节点)开始，左半边为非叶子节点，右半边为叶子节点。
    for (int i = nums.size() / 2 - 1; i >= 0; i--) {
        heapAdjust(nums, i, nums.size() - 1);
    }
    // 取堆顶，并且调整
    for (int i = nums.size() - 1; i > 0 ; i--){
        swap(nums[0], nums[i]);// 把堆顶元素交换至后面。
        heapAdjust(nums, 0, i - 1);// 对剩下的元素进行排序
    }
}

int main()
{
    vector<int> nums = {3, 5, 10, 16, 32, 23, 7, 4, 6};
    cout << "Before Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    heapSort(nums);
    cout << "After Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}

归并排序

原理：把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

代码实现：

#include<iostream>
#include<vector>
using namespace std;

// 将两个已经排序好的序列[low, mid]和[mid + 1, high]归并到临时数组temp中
void merge(vector<int>& nums, int low, int mid, int high) {
    vector<int> temp(high - low + 1);// 开辟临时数组
    int m = high - low;// 临时数组的最后一个元素下标
    int i = mid, j = high;// 从2个序列的末尾开始遍历
    while (i >= low && j >= mid + 1) {
        if (nums[i] > nums[j]) temp[m--] = nums[i--];// nums[i]是剩余元素的最大值
        else temp[m--] = nums[j--];// nums[j]是剩余元素的最大值
    }
    while (i >= low) temp[m--] = nums[i--];// 剩余元素直接放入
    while (j >= mid + 1) temp[m--] = nums[j--];// 剩余元素直接放入
    for(int k = low; k <= high; k++) {// 将临时数组元素全部赋给相应的原数组
        nums[k] = temp[k - low];
    }
}

void mergeSort(vector<int>& nums, int low, int high){
    if (low >= high) return;
    int mid = (low + high) / 2;
    mergeSort(nums, low, mid);// 分割
    mergeSort(nums, mid + 1, high);// 分割
    merge(nums, low, mid, high);// 排序
}

int main()
{
    vector<int> nums = {3, 5, 10, 16, 32, 23, 7, 4, 6};
    cout << "Before Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    mergeSort(nums, 0, nums.size() - 1);
    cout << "After Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}

计数排序

原理：当待排序的数的值都是在一定的范围内的整数时，可以用待排序的数作为计数数组的下标，统计每个数的个数，然后依次输出即可。

代码实现：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

void countSort(vector<int>& nums){
    // 找出数组中的最大值
    int maxValue = INT_MIN;
    for (int i = 0; i < nums.size(); i++) {
        maxValue = max(maxValue, nums[i]);
    }

    vector<int> count(maxValue + 1); // 开辟最大值+1的数组空间。
    for (int i = 0; i < nums.size(); i++) {
        count[nums[i]]++;// 开始计数 对应位置存放数组中元素的个数
    }
    
    int id = 0;
    // 更新原数组
    for (int i = 0; i <= maxValue; i++) {
        for (int j = 0; j < count[i]; j++) {// 个数
            nums[id++] = i;
        }
    }
}

int main()
{
    vector<int> nums = {3, 5, 10, 16, 32, 23, 7, 4, 6};
    cout << "Before Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    countSort(nums);
    cout << "After Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}

桶排序

原理：将值为i的元素放入i号桶，最后依次把桶里的元素倒出来。具体的说是每个桶存储一定范围的元素，通过映射函数，将待排序数组中的元素映射到各个对应的桶中，对每个桶中的元素进行排序，最后将非空桶中的元素逐个放入原序列中。

代码实现：

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;

void bucketSort(vector<int>& nums) {
    // 计算最大值与最小值
    int maxValue = INT_MIN;
    int minValue = INT_MAX;
    for (int i = 0; i < nums.size(); i++) {
        maxValue = max(maxValue, nums[i]);
        minValue = min(minValue, nums[i]);
    }
    
    // 计算桶的数量
    int bucketNum = (maxValue - minValue) / nums.size() + 1;
    vector<vector<int>> bucketArr(bucketNum);// 分配桶
    
    // 将每个元素放入桶
    for (int i = 0; i < nums.size(); i++) {
        int num = (nums[i] - minValue) / (nums.size());
        bucketArr[num].push_back(nums[i]);
    }
    
    // 对每个桶进行排序
    for (int i = 0; i < bucketArr.size(); i++) {
        sort(bucketArr[i].begin(), bucketArr[i].end());
    }
    
    // 将桶中的元素赋给原数组
    nums.clear(); // 清空原数组
    for (int i = 0; i < bucketArr.size(); i++) {
        for (int j = 0; j < bucketArr[i].size(); j++) {
            nums.push_back(bucketArr[i][j]);
        }
    }  
}

int main()
{
    vector<int> nums = {3, 5, 10, 16, 32, 23, 7, 4, 6};
    cout << "Before Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    bucketSort(nums);
    cout << "After Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}

基数排序

原理：设置若干个箱子，将关键字为k的记录放入第k个箱子(按照个位、十位、百位等的数字为关键字)，然后再按序号将非空箱子中的记录收集起来，循环往复直至排序完成。

代码实现：

#include<iostream>
#include<vector>
using namespace std;
 
// 求数据的最大位数,决定排序次数
int maxbit(vector<int>& nums, int n) {
    int t = 1; // 保存最大的位数
    int m = 10;
    for (int i = 0; i < n; i++) {
        while (nums[i] >= m) {
            m *= 10;
            ++t;
        }
    }
    return t;
}

//基数排序
void radixSort(vector<int>& nums, int n) {
    int t = maxbit(nums, n);// 确定最大位数即排序次数
    vector<int> temp(n);// 创建容纳这n个数的临时数组
    vector<int> count(10); // 计数器 统计每个记录数出现的次数
    int i, j, k;
    int radix = 1;// 位数的权重
    for (i = 1; i <= t; i++) {// 进行t次排序
        for (j = 0; j < 10; j++) {
            count[j] = 0; // 每次分配前清空计数器
        }
        for (j = 0; j < n; j++) {// 统计每个桶中的记录数
            k = (nums[j] / radix) % 10; 
            count[k]++;
        }
        for (j = 1; j < 10; j++) {
            count[j] = count[j - 1] + count[j]; // 将temp中的位置依次分配给每个桶
        }
        for (j = n - 1; j >= 0; j--) {// 将所有桶中记录依次收集到temp中
            k = (nums[j] / radix) % 10;
            temp[count[k] - 1] = nums[j];
            count[k]--;
        }
        for (j = 0; j < n; j++) {// 将临时数组的内容赋给原数组
            nums[j] = temp[j];
        }
        radix = radix * 10;
    }
}
 
int main()
{
    vector<int> nums = {3, 5, 10, 16, 32, 23, 7, 4, 6};
    cout << "Before Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    radixSort(nums, 9);
    cout << "After Sort: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}
为你挡风遮雨
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
基于C++实现的各种内部排序算法汇总
12-31
（另：至于堆排序算法，前面已经有一篇文章针对堆排序的算法实现做了详细的描述） C++实现代码如下： /************************************************************************* > File Name: sort.cpp > ...
【C++】十大排序算法原理、代码、时空复杂度and稳定性分析
saxon_li的博客
12-14 1162
前言：本文排序顺序均为从小到大 一、冒泡排序 1、算法描述 ⽐较相邻的元素。如果第⼀个⽐第⼆个⼤，就交换它们两个； 对每⼀对相邻元素作同样的⼯作，从开始第⼀对到结尾的最后⼀对，这样每一趟排序，所有未排序元素中最后的元素即是最⼤的数； 重复复以上两步骤 n - 1 次（ n 为数组的大小），直到排序完成。 2、代码展示 void bubbleSort(vector<int>& num) { int n=num.size(); for(int i=0;i
C++实现十大排序算法（冒泡排序、选择排序、插入排序、希尔排序、归并排序、堆排序、快速排序、计数排序、桶排序和基数排序）
徐丨若木
09-22 1743
目录 0 概述 1 冒泡排序 2 选择排序 3 插入排序 4 希尔排序 5 归并排序 6 堆排序 7 快速排序 8 计数排序 9 桶排序 10 基数排序 本文为C++实现的十大排序算法及基于排序算法解决的一些常见问题，每一种算法均实际运行，确保正确无误。文中内容为自己的一些理解，如有错误，请大家指正。 0 概述 在十种排序算法中，前七种是比较类排序，后三种是非比较类排序，每种算法的最好、最坏、平均时间复杂度，空间复杂度以及稳定性如下表所示。稳定性是指排序前后相等的元素相对位置保.
排序算法总结(一)
xiao_Hebut的博客
09-04 306
0排序算法说明 0.1排序的定义 对一序列对象根据某个关键字进行排序 0.2 术语说明 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面； 不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面； 内排序：所有排序操作都在内存中完成； 外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行； 时间复杂度：一个算法执行所耗费...
十大排序算法详细分析总结+图解及个人思考(上篇)-C++实现
qq_45966201的博客
04-24 1127
排序算法在学校考试，企业面试中都是高频高点，为了更加透彻的学习这十大算法，就整理了本篇博客：详细讲解分析十大算法，包含文字总计和图解分析，方便日后复习回顾。
C++：主要几种排序算法及其复杂度
dienangpiao2051的博客
10-26 329
常见排序算法稳定性和复杂度分析快速简记以及转载 分类： 算法 2012-02-07 22:18 399人阅读 评论(1) 收藏 举报 算法mergeshell http://blogold.chinaunix.net/u3/94667/showart_2150464.html 1.排序算法的稳定性分析: 若待排序的序列中，存在多个具有相同关键字的记录，经过排序，这些记录的相对...
排序算法的稳定性和时间复杂度小结
07-08
小排序算法的稳定性和时间复杂度
详细总结C++的排序算法
12-26
区分稳定与不稳定：快速、希尔、堆、选择不稳定，其他排序算法均稳定。 平均时间复杂度：冒泡，选择，插入是O(n2)，其他均是O(n*log2n) 最坏时间复杂度：冒泡，选择，插入，快排是O(n2)，其他是O
c++中八大排序算法
12-31
排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 我们这里说说八大排序就是内部排序。 当n较大，则应...
C++实现桶排序（源代码）
最新发布
05-07
此外，桶排序需要额外的空间来存储桶和桶内的数据，且对数据的稳定性敏感。在C++实现中，可以通过根据数据范围和数组大小来设定桶的大小，并使用标准库中的排序函数对每个桶进行排序，最后再将排序后的数据合并回原...
各种排序算法的稳定性和时间复杂度总结
08-23
各种排序算法的稳定性和时间复杂度总结。希望大家能有所收获。
各种排序算法的稳定性和时间复杂度小结
03-28
各种排序算法的稳定性和时间复杂度小结，包含各种排序算法，对找工作，做项目都有帮助
数据结构与算法笔记 —— 十大经典排序及算法的稳定性
别呀的博客
09-15 1557
排序与搜索 排序算法（英语: Sorting algorithm）是一种能将一串数据依照特定顺序进行排列的一种算法。 排序算法的稳定性 稳定性︰稳定排序算法会让原本有相等键值的纪录维持相对次序。也就是如果一个排序算法是稳定的，当有两个相等键值的纪录R和S，且在原本的列表中R出现在S之前，在排序过的列表中R也将会是在S之前。 当相等的元素是无法分辨的，比如像是整数，稳定性并不是一个问题。然而，假设以下的数对将要以他们的第一个数字来排序。 (4,1) (3,1) (3,7) (5,6) 在这个状况下，有可能产
【常见的十种排序算法及稳定性比较】
阿年的博客
03-29 1661
插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序、基数排序、基数排序、桶排序，以及稳定性比较，总结
C++——排序的稳定性
小天狼星_布莱克 的博客
06-26 1405
排序算法的稳定性
10种 排序算法 稳定性，复杂度的分析
u011644138的博客
04-18 1745
排序项：排序依据的数据 关键码：主关键码，次关键码，主关键码对于任意排序的序列结果唯一，关键码是次关键码排序结果不一定唯一，由于才可能存在相同的关键值记录。 内部排序：排序过程中全放入内存中。 外部排序：排序过程使用内外数据交换，主要部分放在外存中。 1. 冒泡排序：时间复杂度为 0(n2) 2. 直接插入排序： private static void sort(int...
C++ 经典排序算法原理及稳定性分析
weixin_52626887的博客
09-18 1325
排序算法
c++排序算法稳定性判断详解
Yoyo的博客
09-12 240
当谈到排序算法时，一个重要的概念是稳定性。排序算法的稳定性指的是当两个相等的元素在排序后保持相对位置不变。换句话说，如果有两个元素A和B，它们的值相等并且在排序之前A出现在B之前，那么在排序之后，A仍然应该出现在B之前。本文将深入探讨排序算法的稳定性，以及如何实现稳定的排序算法。在工程和科学领域中，我们经常需要对数据进行排序以便更好地分析和处理。排序算法在计算机科学中起着至关重要的作用，因此了解排序算法的性质是很有必要的。排序算法的稳定性可以理解为对于相等的元素，排序前后它们的相对位置是否被改变。
八种排序算法详解
qq_44544313的博客
10-12 623
排序算法的比较 1、稳定性 归并排序、冒泡排序、插入排序。基数排序是稳定的 选择排序、快速排序、希尔排序、堆排序是不稳定的 2、时间复杂度 最基础的四个算法：冒泡、选择、插入、快排中，快排的时间复杂度最小O(n*log2n)，其他都是O（n2） 排序法 平均时间 最差情形 稳定度 额外空间 备注 冒泡 O(n2) O(n2) ...
vector排序算法的时间复杂度
07-28
- *2* [常见的十种排序算法C++实现（附时空复杂度，稳定性分析）](https://blog.csdn.net/Xavier_97/article/details/126722423)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值