十大排序算法（c++实现）

已于 2024-04-02 20:23:25 修改
阅读量391 收藏 4
点赞数 5
文章标签： 排序算法 c++ 算法
于 2024-04-02 20:07:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gqb111/article/details/137247691
版权
本文详细介绍了C++中的10种基本排序算法：冒泡排序、选择排序、插入排序、希尔排序（优化插入）、快速排序、归并排序（分治法）、计数排序、基数排序、堆排序（最大堆）以及桶排序，展示了它们的时间复杂度和适用场景。
摘要由CSDN通过智能技术生成

1.冒泡排序 o(n^2)

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
void maopao(vector<int>& t) {
    for (int i = 0; i < t.size()-1; i++) {
        bool flag = false;
        for (int j = 0; j < t.size() - i - 1; j++) {
            if (t[j] > t[j + 1]) {
                swap(t[j], t[j + 1]);
                flag = true;
            }
        }
        if (flag == false)
            break;
    }
}
int main() {
    vector<int> t{ 9,9,8,7,8,6,6,5,4,3 };
    maopao(t);
    for (auto i = t.begin(); i != t.end(); i++)
        cout << *i << " ";
    cin.get();
}

2.选择排序:每一轮选择最小的元素在已排序集合后面（时间复杂度o(n^2)）稳定

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
void xuanze(vector<int>& t) {
    int k;
    for (int i = 0; i < t.size(); i++) {
        k = i;
        for (int j = i+1; j < t.size(); j++) {
            if (t[j] < t[i]) k = j;
        }
        swap(t[k], t[i]);
    }
}
int main() {
    vector<int> t{ 9,8,7,6,5,4,3,2,1,0 };
    xuanze(t);
    for (auto it = t.begin(); it != t.end(); it++)
        cout << *it << " ";
    cin.get();
}

3.插入排序（数组基本有序时效率高）每一轮将元素插入到已排序的集合中o(n^2) 最好是n，稳定

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
void charu(vector<int>& t) {
    for (int i = 1; i < t.size(); i++) {
        for (int j = i; j > 0; j--) {
            if (t[j] < t[j - 1])
                swap(t[j], t[j - 1]);
            else
                break;
        }
    }
}
int main() {
    vector<int> t{ 9,8,7,6,5,4,3,2,1,0 };
    charu(t);
    for (auto it = t.begin(); it != t.end(); it++)
        cout << *it << " ";
    cin.get();
}

4.希尔排序(优化版的插入排序，适用于长数组，优化了步长，逐渐减少至1，变为插入）o(n^2) 不稳定

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
void xier(vector<int>& t) {
    int n = 1;
    int m = t.size() / 3;
    while (n < m)
        n = 3 * n + 1;
    while (n > 0) {
        for (int i = n; i < t.size(); i++) {
            for (int j = i; j >= n; j-=n) {
                if (t[j] < t[j - n])
                    swap(t[j], t[j - n]);
            }
        }
        n /= 3;
    }
}
int main() {
    vector<int> t{ 9,8,7,6,5,4,3,3,2,2,1,0 };
    xier(t);
    for (auto it = t.begin(); it != t.end(); it++)
        cout << *it << " ";
    cin.get();
}

5.快速排序（冒泡的优化版本，每次递归后把轴放在中间，使得轴比左大比右小）（仅数组，若要在链表上实现需要改为遍历只涉及从一端到另一端）

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
void kuaisu(vector<int>& t,int left, int right) {
    int i = left, j = right;
    if (left >= right)
        return;
    int pivot = t[i];
    while (i < j) {
        while (i<j&&t[j] >= pivot) j--;
        t[i] = t[j];
        while (i < j && t[i] <= pivot) i++;
        t[j] = t[i];
    }
    t[i] = pivot;
    kuaisu(t, left, i - 1);
    kuaisu(t, i + 1, right);
}
int main() {
    vector<int> t{ 1,2,3,4,5,9,7,8,9,11,11};
    kuaisu(t,0,t.size()-1);
    for (auto it = t.begin(); it != t.end(); it++)
        cout << *it << " ";
    cin.get();
}

6.归并排序（分治思想）空间复杂度o(n)，时间复杂度o(nlogn)

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
void mmerge(vector<int>& t, vector<int>& temp, int left, int mid, int right) {
    int i = left;
    int j = mid + 1;
    int pos = left;
    while (i <= mid && j <= right) {
        temp[pos++] = (t[i] <= t[j]) ? t[i++] : t[j++];
    }
    while (i <= mid)
        temp[pos++] = t[i++];
    while (j <= right)
        temp[pos++] = t[j++];
    while (left <= right) {
        t[left] = temp[left];
        left++;
    }
}
// 划分子区间
void guibing(vector<int>& t, vector<int>& temp, int left, int right) {
    int mid = left + (right - left) / 2;
    if (left < right) {
        guibing(t, temp, left, mid);
        guibing(t, temp, mid + 1, right);
        mmerge(t, temp, left, mid, right);
    }
}
// 排序入口
void rukou(vector<int>& t, int left, int right) {
    vector<int> temp;
    temp.resize(t.size());
    guibing(t, temp, 0, t.size() - 1);
}
int main() {
    vector<int> t{ 9,8,7,7,100,100,3,97,1,0 };
    rukou(t, 0, static_cast<int>(t.size()) - 1);
    for (auto it = t.begin(); it != t.end(); it++)
        cout << *it << " ";
    cin.get();
}

7.计数排序（利用数组下标天然有序）

#include<iostream>
#include<vector>
using namespace std;
void jishu(vector<int>& t) {
    vector<int>temp(100, 0);
    for (int i = 0; i < t.size(); i++) {
        temp[t[i]]++;
    }
    for (int i = 0,j=0; i < temp.size(); i++) {
        while (temp[i]--) {
            t[j++] = i;
        }
    }
}
int main() {
    vector<int>t{ 9,8,7,6,6,5,5,4,3,2,1,1,0 };
    jishu(t);
    for (auto i = t.begin(); i < t.end(); i++)
        cout << *i << " ";
    cin.get();
}

8.基数排序

#include<iostream>
#include<vector>
using namespace std;
void jishutong(vector<int>& t) {
    int j;
    int pos;
    for (int k = 10; k < 10000; k *= 10) {
        vector<vector<int>>temp(10);
        for (int i = 0; i < t.size(); i++) {
            j = 0;
            pos = (t[i] / k) %10;
            temp[pos].push_back(t[i]);
        }
        //遍历一轮后写入源容器
        pos = 0;
        for (int i = 0; i < temp.size(); i++) {
            for (int j = 0; j < temp[i].size(); j++) {
                t[pos++] = temp[i][j];
            }
        } 
    }
}
int main() {
    vector<int>t{ 965,987,798,665,645,565,545,445,323,89};
    jishutong(t);
    for (auto i = t.begin(); i < t.end(); i++)
        cout << *i << " ";
    cin.get();
}
9.堆排序  维护堆：o(logn) 建堆：o(n)

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
void weihu(vector<int>& t,int n,int i) {
    int tar = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    if (left < n && t[tar] < t[left])
        tar = left;
    if (right < n && t[tar] < t[right])
        tar = right;
    if (tar != i){
        swap(t[i], t[tar]);
        weihu(t,n,tar);
    }
}
void create(vector<int>& t,int n) {
    int i;
    for (i = n/2-1; i >= 0; i--) {
        weihu(t,n,i);
    }
    for (int i = t.size()-1; i >0; i--) {
        swap(t[i], t[0]);
        weihu(t,i,0);
    }
}

int main() {
    vector<int> t{ 8,4,5,6,5,4,3,1,2 };
    create(t,t.size());
    for (auto i = t.begin(); i != t.end(); i++)
        cout << *i << " ";
    cin.get();
}

10.桶排序

是计数排序和基数排序的基础：首先根据取值范围将数组内元素放入各个桶中，在每个桶运用某个排序算法进行排序，最后合并；

gqb111
关注
排序算法——C++实现
观则明的博客
10-05 1400
排序算法——C++实现
经典排序算法C++实现（10种）
weixin_42023936的博客
08-27 2844
C++实现经典排序算法插入排序希尔排序（缩小增量排序）选择排序堆排序冒泡排序冒泡排序的原理：快速排序合并排序折中排序新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章U...
快速排序算法C++实现（超详细解析！！！！）
热门推荐
weixin_45031801的博客
09-21 9万+
快速排序，其实是一种分治算法，那么在了解快速排序之前，我们先来看看什么是分治算法。在算法设计中，我们引入分而治之的策略，称为分治算法，其本质就是将一个大规模的问题分解为若干个规模较小的相同子问题，分而治之。
【数据结构】十大排序算法C++实现
qq_42147969的博客
05-12 7744
参考 数据结构十大排序算法讲解：算法原理和LeetCode代码实现（C++，java） 【数据结构】十大排序算法—— C++实现＜全＞ 十大经典排序算法（C++实现）
十种常见排序算法及其C++实现
aiyouweihei_001的博客
01-09 1502
十种排序算法的介绍及C++实现：冒泡、插入、希尔、选择、快排、堆排序、归并、桶排序、基数、计数
c++十大经典排序算法
客舟中
12-28 8214
代码 1 冒泡排序 冒泡排序是一种简单直观的入门排序算法。它的原理就是从第一个元素开始，与后面的元素逐个比较，如果顺序不对就交换，直到没有可比较的元素为止。 1 // 冒泡排序 2 void BublingSort(int *arr, int len) 3 { 4 if(len == 0) 5 { 6 return; 7 } 8 std::cout<<"冒泡排序"<<std::endl; 9 for(i
十大排序算法（C++版）
CltCj的博客
02-03 4878
十大排序算法前言一、直接插入排序二、折半插入排序三、希尔排序总结 前言 什么是排序？   排序：将一组杂乱无章的数据按一定规律顺次排列起来。即，将无序序列排成一个有序序列（由小到大或由大到小）的运算。 排序方法的分类   按数据存储介质：内部排序和外部排序   按比较器个数：串行排序和并行排序   按主要操作：比较排序和基数排序   按辅助空间：原地排序和非原地排序   按稳定性：稳定排序和非稳定排序   按自然性：自然排序和非自然排序 一、直接插入排序 基本思想：   每步将一个待排序的对象
用C++实现十大经典排序算法
billy的博客
01-04 8470
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。
C++实现十大排序算法
liuzuoping的博客
12-03 1万+
今天我们来用C++实现一下经典的十大排序算法 具体代码与文件可访问我的GitHub地址获取 https://github.com/liuzuoping/Algorithms PS：欢迎star 1 冒泡排序 冒泡排序无疑是最为出名的排序算法之一，从序列的一端开始往另一端冒泡（你可以从左往右冒泡，也可以从右往左冒泡，看心情），依次比较相邻的两个数的大小（到底是比大还是比小也看你心情）。 （无序区...
常见的十种排序算法C++实现（附时空复杂度，稳定性分析）
Xavier_97的博客
09-07 3877
每一轮排序使得当前无序的部分的最大值冒到当前无序数组的末尾，下一轮中无序部分的长度等于上一轮减一，原数组的末端不断的变成有序的部分。时间复杂度最坏和平均情况是O()，最好的情况是已经有序所以是O(n)，空间复杂度O(1)，且因为两个相同的元素是不会交换位置的，因此是一种稳定的排序。
十大排序算法c++实现_fish.rar
05-06
十大排序算法c++实现，建议结合下面这篇文章看 ...
十大排序算法C++代码
09-27
十大排序算法C++代码
基于C++实现的各种内部排序算法汇总
12-31
（另：至于堆排序算法，前面已经有一篇文章针对堆排序的算法实现做了详细的描述） C++实现代码如下： /************************************************************************* > File Name: sort.cpp > ...
考研排序算法C++实现
11-02
考研排序算法C++实现
【数据结构】选择排序
最新发布
wheeldown的博客
11-04 273
时间复杂度：O（n^2）直接选择排序的动图演示。选择排序总体思路解析。
冒泡排序、选择排序、计数排序、插入排序、快速排序、堆排序、归并排序JAVA实现
青山师
11-04 1319
冒泡排序、选择排序、计数排序、插入排序、快速排序、堆排序、归并排序JAVA实现。
C/C++每日一练：实现选择排序
weixin_60461563的博客
10-28 710
实现一个选择排序算法，用于对整数数组进行升序排序。输入是一个包含若干整数的数组，输出是排序后的数组。要求在原数组上进行排序，不借助额外的数组空间（即就地排序）。选择排序的基本思想是：每次从未排序部分选择最小的元素，将其放到已排序部分的末尾。这样经过多轮操作后，整个数组会被逐步排好序。假设有一个数组 arr，长度为 n。，其中 n 是数组长度，不适合大数据集的排序，适合于元素较少且对性能要求不高的场景。选择排序是一种简单直观的排序算法，时间复杂度为。
《Java 实现选择排序：原理剖析与代码详解》
qq_69304031的博客
11-03 536
选择排序作为一种简单直观的排序算法，虽然在效率上可能不如一些更高级的排序算法，但它是理解排序概念的一个很好的入门选择。选择排序的基本思想是：在未排序的序列中找到最小（或最大）的元素，然后将其与未排序序列的第一个元素进行交换位置。接着，在剩余的未排序序列中继续寻找最小（或最大）元素，并与未排序序列的第二个元素进行交换，以此类推，直到整个序列都被排序完成。简单来说，每一轮排序都能确定一个元素在最终有序序列中的位置，经过多次这样的轮次，就能将整个数组排序好。，这样就能准确找到这一轮未排序序列中的最小值及其下标。
《Java 实现快速排序：原理剖析与代码详解》
qq_69304031的博客
11-03 749
排序算法在数据处理和计算机编程领域中占据着举足轻重的地位，它们能够将无序的数据按照特定的规则整理成有序的序列，方便后续的分析与操作。在我们给出的代码中，选取的是数组的第一个元素作为基准值。在完成一次划分操作后，基准值就处于它在排序后应该所处的大致位置（即左边的元素都比它小，右边的元素都比它大）。将数组划分为两部分，使得左边部分的所有元素都小于等于基准值，右边部分的所有元素都大于等于基准值。来交换它们所指向的元素，使得数组的左边部分逐渐出现小于等于基准值的元素，右边部分逐渐出现大于等于基准值的元素。
快速排序算法C++实现详解
资源摘要信息:"快速排序算法C++实现" 快速排序（Quick Sort）是一种高效的排序算法，由C. A. R. Hoare在1960年提出。它的基本思想是分治法（Divide and Conquer）。快速排序的平均时间复杂度为O(n log n)，最坏情况...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值