冒泡排序、插入排序、选择排序、归并排序、快速排序算法（C++实现）

已于 2024-10-09 10:01:54 修改
阅读量534 收藏 7
点赞数 2
分类专栏： C/C++专栏 文章标签： c++ 排序算法 算法 数据结构 开发语言
于 2024-10-08 19:23:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/S13352784013/article/details/142767156
版权

文章目录

一、冒泡排序

冒泡排序应该算是最经典最简单的排序算法，我一开始学习排序算法就是从冒泡排序开始入门的。
冒泡排序算法的基本思路：（循环遍历，相邻元素比较）

  1. 冒泡排序通过多轮遍历数组，每一轮比较相邻的元素，如果相邻元素的顺序不符合要求（升序或降序），则交换它们的位置。
  2. 每一轮重复以上的比较操作，就会将当前未排序的最大（升序）或者最小（降序）元素排序到数组的末尾位置。
  3. 重复以上步骤，直到一轮遍历中没有发生任何交换，表示数组已经排序完成。
  4. 循环遍历的次数最多n-1次，最少为1次。
    时间复杂度：最好为O(n) 最差为O(n^2)
    空间复杂度：O(1)

上浮法冒泡排序（从小到大排序）

#include <iostream>
#include <vector>

using namespace std;

void bubbleSortUp(vector<int> &nums)
{
    for (int i = 0; i < nums.size() - 1; i++)
    {
        bool isSwap = false;
        for (int j = 0; j < nums.size() - i - 1; j++)
        {
            if (nums[j] > nums[j + 1])
            {
                swap(nums[j], nums[j + 1]);
                isSwap = true;
            }
        }

        if (isSwap == false)
        {
            cout << "排序已完成" << endl;
            break;
        }
    }
}

int main(int argc, char const *argv[])
{
    vector<int> nums = {5, 6, 675, 4, 43, 63, 1, 2, 3, 8, 5, 6, 675, 4, 43, 63, 1, 2, 3};
    bubbleSortUp(nums);
    for (auto num : nums)
    {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}

下浮法冒泡排序（从大到小排序）

如果会了上浮法冒泡排序，那下浮法的就很简单，只需要将上浮法中的if (nums[j] > nums[j + 1])改成if (nums[j] < nums[j + 1])即可。
时间复杂度：最好为O(n) 最差为O(n^2)
空间复杂度：O(1)

#include <iostream>
#include <vector>

using namespace std;

void bubbleSortUp(vector<int> &nums)
{
    for (int i = 0; i < nums.size() - 1; i++)
    {
        bool isSwap = false;
        for (int j = 0; j < nums.size() - i - 1; j++)
        {
	        // 下浮法只需要修改这里即可
            if (nums[j] < nums[j + 1])
            {
                swap(nums[j], nums[j + 1]);
                isSwap = true;
            }
        }

        if (isSwap == false)
        {
            cout << "排序已完成" << endl;
            break;
        }
    }
}

int main(int argc, char const *argv[])
{
    vector<int> nums = {5, 6, 675, 4, 43, 63, 1, 2, 3, 8, 5, 6, 675, 4, 43, 63, 1, 2, 3};
    bubbleSortUp(nums);
    for (auto num : nums)
    {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}

二、选择排序

选择排序算法的基本思路：（循环遍历，找到最小元素并交换位置）

  1. 遍历整个列表的n个元素，找到最小的元素，与第一个元素交换位置。
  2. 遍历列表剩余的n-1个元素，找到最小的元素，与第二个元素交换位置。
  3. 以此类推，重复以上步骤，直到需要遍历的列表元素个数小于等于1，则表示排序完成。
    时间复杂度：O(n^2)
    空间复杂度：O(1)
#include <iostream>
#include <vector>

using namespace std;

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

int main(int argc, char const *argv[])
{
    vector<int> nums = {-1, -181, 0, 0, 5, 6, 675, 4, 43, 63, 1, 2, 3, 8, 5, 6, 675, 4, 43, 63, 1, 2, 3, -999};
    selectSort(nums);
    for (auto num : nums)
    {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}

三、插入排序

插入排序算法的基本思路：（逐个取出元素，与前面有序部分依次比较并插入正确位置）

  1. 从第二个元素开始，将这个元素作为待插入元素与前面有序的元素进行比较；
  2. 如果待插入的元素比前面有序的元素小，则将有序的元素往后移动，相当于腾出空间；
  3. 继续比较和移动，直到找到合适的位置（大于等于前一个数且小于等于后一个数），将待插入的元素放入该位置；
  4. 重复上述步骤，直到整个数组有序。
    时间复杂度：正序时最好为O(n) 逆序时最差为O(n^2)
    空间复杂度：O(1)
#include <iostream>
#include <vector>

using namespace std;

void insertSort(vector<int> &nums)
{
    for (int i = 1; i < nums.size(); i++)
    {
        int j = i - 1;
        int temp = nums[i];
        while (j >= 0 && nums[j] > temp)
        {
            nums[j + 1] = nums[j];
            j--;
        }
        nums[j + 1] = temp;
    }
}

int main(int argc, char const *argv[])
{
    vector<int> nums = {-43, 3, 4, 124, 2345, 456, 5, 6, 7, 6, 5, 0, 12, 33, 3, 22, 2, 77, 2, 34, 55, 5, 56, 1, 100, 88, 21, 99};
    insertSort(nums);
    for (auto num : nums)
    {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}

一开始在写插入排序时，我用到了另一种方法：这种方法虽然也能实现排序，但是这种方法似乎不太符合插入排序的基本思路，而且用到了swap，在一定程度上会增加时间复杂度。

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

四、归并排序

归并排序有两种实现方法，一种是递归，一种是迭代。
归并排序的基本思路：（分治算法）

  1. 分解，将待排序的数组从中间分成两半，分别递归地对这两半进行排序，不断分解，直到数组的长度为 1，此时每个子数组都被视为有序。
  2. 合并，将子数组两两合并，合并的过程中排序，按大小顺序将元素从两个子数组中取出，形成一个新的有序数组。
    归并排序算法的特点：
  3. 是稳定排序算法
  4. 速度仅次于快速排序
  5. 一般用于对总体无序，但是各子项相对有序的数列。
    时间复杂度：O(nlogn)
    空间复杂度：O(n)
#include <iostream>
#include <vector>
using namespace std;

/**
 * 归并函数（二路合并）
 * start:第一段的首元素索引
 * mid:第二段的首元素索引
 * end:第二段的末尾元素索引
 */
void merge(vector<int> &nums, const int start, const int mid, const int end)
{
    vector<int> merArray;
    int p1 = start;
    int p2 = mid;

    while (p1 < mid && p2 <= end)
    {
        if (nums[p1] <= nums[p2])
        {
            merArray.push_back(nums[p1++]);
        }
        else
        {
            merArray.push_back(nums[p2++]);
        }
    }

    // 将剩余的元素加入到merArray
    while (p1 < mid)
    {
        merArray.push_back(nums[p1++]);
    }
    while (p2 <= end)
    {
        merArray.push_back(nums[p2++]);
    }

    int pos = start;
    for (auto it : merArray)
    {
        nums[pos++] = it;
    }
}

/**
 * 用迭代的方法实现归并排序
 * 时间复杂度：O(nlogn)
 * 空间复杂度：O(n)，因为排序过程中多次拆分的子数组需要放在内存
 */
void mergeSortIteration(vector<int> &nums)
{
    for (int i = 0; i < nums.size(); i++)
    {
        int start = 0;
        int len = 1 << i;
        if (len > nums.size())
            break;
        while (start < nums.size())
        {
            // 注意区分这里的mid和传入merge函数的mid+1
            // mid是第一段的末尾元素，mid+1是第二段的首元素
            int mid = start + len - 1;
            if (mid >= nums.size())
                break;
            int end = min(start + 2 * len - 1, (int)nums.size() - 1);
            merge(nums, start, mid + 1, end);
            start += len * 2;
        }
    }
}

/**
 * 用递归的方法实现归并排序
 * 时间复杂度：O(nlogn)
 * 空间复杂度：O(n)，因为排序过程中多次拆分的子数组需要放在内存
 * 传参都是统一传递有效索引
 */
void mergeSortRecursion(vector<int> &nums, int start, int end)
{
    if (start < end)
    {
        int mid = (start + end) / 2;
        mergeSortRecursion(nums, start, mid);
        mergeSortRecursion(nums, mid + 1, end);
        merge(nums, start, mid + 1, end);
    }
}

int main(int argc, char const *argv[])
{
    vector<int> nums = {-43, -22, 8, 44, 11, 223, 4, 0, 1, 2, 2, 3, 3, 33, 3};
    mergeSortIteration(nums); // 迭代法
    // mergeSortRecursion(nums, 0, nums.size() - 1); // 递归法
    for (int num : nums)
    {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}

五、快速排序

快速排序采用的也是分治的策略，它是一种基于二叉树结构的交换排序算法。快速排序是一种不稳定的排序方法，但是他的效率非常高。
快速排序算法的基本思路：

  1. 先从数列中取出一个数作为基准数，然后将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边；
  2. 对左右区间重复步骤一的操作，直到各区间只有一个数。
    时间复杂度：最差为O(n^2)，平均为O(NlogN)
    空间复杂度：受递归深度影响，最好为O(logn)，最差为O(n)
#include <iostream>
#include <vector>

using namespace std;

/**
 * 快速排序算法（左右指针法/hoare法）
 * 时间复杂度：最差为O(n^2)，平均为O(NlogN)
 * 空间复杂度：受递归深度影响，最好为O(logn)，最差为O(n)
 */
void quickSort(vector<int> &nums, int begin, int end)
{
    if (begin >= end)
        return;
    // 保存左右节点
    int left = begin;
    int right = end;
    // 选取第begin节点为key
    int key = begin;

    while (begin < end)
    {
        // 右边选小，遇到大于nums[key]的数就跳过
        while (begin < end && nums[end] >= nums[key])
        {
            end--;
        }
        // 左边选大，遇到小于nums[key]的数就跳过
        while (begin < end && nums[begin] <= nums[key])
        {
            begin++;
        }
        swap(nums[begin], nums[end]);
    }
    // 交换相遇点的值和nums[key]值
    swap(nums[key], nums[begin]);
    key = begin;
    // 递归
    quickSort(nums, left, key - 1);
    quickSort(nums, key + 1, right);
}

int main(int argc, char const *argv[])
{
    vector<int> nums = {-43, -22, 8, 44, 11, 223, 4, 0, 1, 2, 2, 3, 3, 33, 3};
    quickSort(nums, 0, nums.size() - 1);
    for (auto num : nums)
    {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}

参考

  1. C++实现排序算法_c++从小到大排序-CSDN博客
  2. 常见的几种排序算法（c++）_c++排序算法-CSDN博客
  3. 六大排序算法：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序-CSDN博客
代码能跑就可以
关注
专栏目录
冒泡排序/插入排序/选择排序/快速排序/归并排序C++详细代码
weixin_56281544的博客
05-14 394
冒泡排序：比较相邻的元素，如果第一个比第二个大，就相互交换，对每一对相邻的元素做相同的工作，第一次排序使最大的元素移动到最右端；进行第二次排序，同样的步骤使次大的元素移动到n-1的位置上；重复上述步骤，直到排序完成。 class Solution { public: vector<int> BubbleSort(vector<int>& arr) { //冒泡排序 int n = arr.size(); for(int i=..
排序算法：基于C++实现的插入排序、冒泡排序与选择排序
fantasticHQ的博客
04-23 2万+
本文介绍了三种基础的排序算法：插入排序、冒泡排序和选择排序,三种排序适合于小型数据或基本有序的数据集，在实际应用中，更高效的排序算法（如快速排序、归并排序等）通常更受欢迎。
C++实现排序 - 01 冒泡、选择、插入和希尔排序
Newin2020的博客
06-28 2000
冒泡排序正如其名，这个算法像是泡泡一样往上升，具体步骤如下：为了方便理解，我们还是来看图：第一步：比较第一个元素与第二个元素，不存在逆序，后移一位。第二步：比较第二个元素和第三个元素，不存在逆序，后移一位。第三步：比较第三个元素和第四个元素，不存在逆序，后移一位。第四步：比较第四个元素和第五个元素，存在逆序，交换两者，后移一位。第五步：比较第五个元素和第六个元素，存在逆序，交换两者，后移一位。第六步：比较第六个元素和第七个元素，存在逆序，交换两者，后移一位。第七步：比较第七个元素和第八个元素，存在逆序，交换
C++ sort()排序详解
热门推荐
晴空๓
05-05 43万+
本文对C++中的sort()做了一个比较详细的说明，包括为什么选择使用sort()、sort()函数的实现原理、sort()的使用方法等等。
C++实现 直接插入排序，选择排序，冒泡排序，快速排序，简单计数排序，归并排序
weixin_43960713的博客
03-11 3160
C++ 实现 直接插入排序，选择排序，冒泡排序，快速排序，简单计数排序，归并排序 vector
C++排序算法实现及原理精析：冒泡、选择、插入、快速、归并排序
weixin_43520503的博客
01-06 560
文章目录2.2 冒泡排序2.3 选择排序2.6 插入排序2.7 快速排序2.8 归并排序 2.2 冒泡排序 排序逻辑： 从左向右扫描数据，选择最大的数据，放在右边。 要点：从左边开始，比较相邻的两个数字，如果左边的数字大于右边的，就进行交换。，第一趟拍完，会将最大的数字排放在最后的位置，第二趟排完会将第二大的数字排放在倒数第二个，以此类推直到排序结束。 后续过程依次类推即可。 排序实现： #include <iostream> #include <algorithm> #i
C++ 常用排序算法（冒泡排序 插入排序 选择排序 快速排序 归并排序 堆排序）
csdn_aspnet的专栏
02-02 1万+
选择排序（Selection Sort）：每次从未排序部分选择最小的元素，并将其与未排序部分的首元素交换位置。时间复杂度为O(n^2)，但对于小规模的数组或部分有序的数组，具有较好的性能。归并排序（Merge Sort）：将数组递归地分成两半，分别进行排序，然后将排序后的子数组进行合并。冒泡排序（Bubble Sort）：通过不断交换相邻的元素，将最大的元素逐渐向数组的末尾冒泡。时间复杂度为O(n^2)。这些算法都是常见的排序算法，在实际应用中根据不同的场景和需求选择合适的算法，以达到最佳的排序效果。
C++实现十大排序算法(冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、计数排序、基数排序、堆排序、桶排序)
weixin_53617926的博客
05-20 705
【代码】C++实现十大排序算法(冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、计数排序、基数排序、堆排序、桶排序)
2.C++-选择排序、冒泡排序、插入排序、希尔排序、归并排序、快速排序
抵抗时间扭曲，坚持做一件有意义的事
01-04 6347
1.常用排序算法介绍 一个排序算法的好坏需要针对它在某个场景下的时间复杂度和空间复杂度来进行判断、并且排序都需要求其稳定性,比如排序之前a在b前面,且a=b,排序之后也要保持a在b前面、 常用排序算法如下所示: 2.选择排序 首先i等于0,每次i++,并从i轮询到n,选择一个最小者与第i个位置进行交换. 比如: 16,8,21,10,49 第1次遍历整个数组,找到最小值8,则与arr[0]进行交换: 8,16,21,10,49 第2次遍历下标1~4的数组,找到10,则与arr[1]进
C++实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
在本文中，我们将深入探讨C++实现的八种常见的排序算法，它们分别是插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序。这些排序算法在计算机科学中有着广泛的应用，是理解和掌握...
C/C++排序算法实现，冒泡排序、简单选择排序、直接插入排序、希尔排序、堆排序、归并排序、快速排序
12-26
C/C++排序算法实现 1、冒泡排序 2、简单选择排序 3、直接插入排序 4、希尔排序 5、堆排序 6、归并排序 7、快速排序
C++冒泡、快速、选择、归并等排序算法实现示例.rar
05-07
本资料包包含C++实现的四种经典排序算法：冒泡排序、快速排序、选择排序和归并排序。下面将分别对这四种排序算法进行详细介绍，并探讨它们的原理、效率和适用场景。 **1. 冒泡排序（Bubble Sort）** 冒泡排序是最...
7种常用排序算法实现（C++）（冒泡排序、选择排序、直接插入排序、希尔排序、堆排序、归并排序以及快速排序）
04-11
这七种算法分别是：冒泡排序、选择排序、直接插入排序、希尔排序、堆排序、归并排序和快速排序。 1. **冒泡排序**： 冒泡排序是最基础的排序算法之一，通过重复遍历待排序序列，比较相邻元素并交换位置来实现排序...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1216
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1724
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
windows C++-创建数据流代理(三)
最新发布
苏洛的博客
10-08 289
控制流指的是程序中操作的执行顺序。 控制流是通过使用条件语句、循环等控制结构调节的。 此外，数据流指的是一种编程模型，在这种模型中，只有当所有需要的数据都可用时，才会进行计算。 数据流编程模型与消息传递这一概念相关，其中程序的独立组件通过发送消息相互通信。 异步代理同时支持控制流和数据流编程模型。 尽管控制流模型适用于许多情况，但数据流模型也适用于其他一些情况，例如，当代理接收数据并执行基于该数据的有效负载的操作时。
【C语言】数据类型和变量
2302_76713442的博客
10-06 1613
一、数据类型分类（内置数据类型：字符型、整型、浮点型和布尔类型）（自定义数据类型：数组、结构体、枚举和联合体）二~三、深入研究内置数据类型（内置数据类型的大小、使用内置数据类型创建变量、signed 和 unsigned）四、自定义数据类型的内容过于庞大，所以每种自定义数据类型都专门写了一篇博客来介绍，文中有相应链接。
【C++力扣】917.仅仅反转字母|387.字符串中第一个唯一字符|415.字符串相加
白乐天_ξ( ✿＞◡❛)的博客
10-06 643
本文写的是力扣三道题的解答：917、387、415题，都是与string字符串有关的！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值