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

已于 2024-10-09 10:01:54 修改
阅读量1k 收藏 8
点赞数 24
分类专栏： 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++实现的插入排序、冒泡排序与选择排序
fantasticHQ的博客
04-23 2万+
本文介绍了三种基础的排序算法：插入排序、冒泡排序和选择排序,三种排序适合于小型数据或基本有序的数据集，在实际应用中，更高效的排序算法（如快速排序、归并排序等）通常更受欢迎。
C++ 常用排序算法（冒泡排序 插入排序 选择排序 快速排序 归并排序 堆排序）
csdn_aspnet的专栏
02-02 4万+
选择排序（Selection Sort）：每次从未排序部分选择最小的元素，并将其与未排序部分的首元素交换位置。时间复杂度为O(n^2)，但对于小规模的数组或部分有序的数组，具有较好的性能。归并排序（Merge Sort）：将数组递归地分成两半，分别进行排序，然后将排序后的子数组进行合并。冒泡排序（Bubble Sort）：通过不断交换相邻的元素，将最大的元素逐渐向数组的末尾冒泡。时间复杂度为O(n^2)。这些算法都是常见的排序算法，在实际应用中根据不同的场景和需求选择合适的算法，以达到最佳的排序效果。
C++实现排序 - 01 冒泡、选择、插入和希尔排序
Newin2020的博客
06-28 2094
冒泡排序正如其名，这个算法像是泡泡一样往上升，具体步骤如下：为了方便理解，我们还是来看图：第一步：比较第一个元素与第二个元素，不存在逆序，后移一位。第二步：比较第二个元素和第三个元素，不存在逆序，后移一位。第三步：比较第三个元素和第四个元素，不存在逆序，后移一位。第四步：比较第四个元素和第五个元素，存在逆序，交换两者，后移一位。第五步：比较第五个元素和第六个元素，存在逆序，交换两者，后移一位。第六步：比较第六个元素和第七个元素，存在逆序，交换两者，后移一位。第七步：比较第七个元素和第八个元素，存在逆序，交换
冒泡排序/插入排序/选择排序/快速排序/归并排序C++详细代码
weixin_56281544的博客
05-14 401
冒泡排序：比较相邻的元素，如果第一个比第二个大，就相互交换，对每一对相邻的元素做相同的工作，第一次排序使最大的元素移动到最右端；进行第二次排序，同样的步骤使次大的元素移动到n-1的位置上；重复上述步骤，直到排序完成。 class Solution { public: vector<int> BubbleSort(vector<int>& arr) { //冒泡排序 int n = arr.size(); for(int i=..
C++ sort()排序详解
热门推荐
晴空๓
05-05 45万+
本文对C++中的sort()做了一个比较详细的说明，包括为什么选择使用sort()、sort()函数的实现原理、sort()的使用方法等等。
【10种排序算法 (C++实现)】
QTSYlyt的博客
07-19 795
算法学习中, 这里给出了常用的10种排序算法的C++代码.
C++实现 直接插入排序，选择排序，冒泡排序，快速排序，简单计数排序，归并排序
weixin_43960713的博客
03-11 3169
C++ 实现 直接插入排序，选择排序，冒泡排序，快速排序，简单计数排序，归并排序 vector
C++排序算法实现及原理精析：冒泡、选择、插入、快速、归并排序
weixin_43520503的博客
01-06 570
文章目录2.2 冒泡排序2.3 选择排序2.6 插入排序2.7 快速排序2.8 归并排序 2.2 冒泡排序 排序逻辑： 从左向右扫描数据，选择最大的数据，放在右边。 要点：从左边开始，比较相邻的两个数字，如果左边的数字大于右边的，就进行交换。，第一趟拍完，会将最大的数字排放在最后的位置，第二趟排完会将第二大的数字排放在倒数第二个，以此类推直到排序结束。 后续过程依次类推即可。 排序实现： #include <iostream> #include <algorithm> #i
2.C++-选择排序、冒泡排序、插入排序、希尔排序、归并排序、快速排序
抵抗时间扭曲，坚持做一件有意义的事
01-04 6367
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. **冒泡排序**： 冒泡排序是最基础的排序算法之一，通过重复遍历待排序序列，比较相邻元素并交换位置来实现排序...
编译器、IDE对C/C++新标准的支持
编程语言技巧经验分享
11-08 1128
很遗憾的是，微软VC++对C99的支持直到VS2015才基本完全支持，在VS2012之前，仅仅支持C89. 也正是2015年之前，这么多人骂微软并纷纷转移到其它C语言编译器的原因。VS2019开始才正式宣布支持C11/C17.对于C++标准，VS2013开始支持C++11，VS2017支持C++17, VS2019支持C++20, 显然，微软更偏爱C++.
C++_用 using 语句继承基类的构造函数
学海无涯
11-09 253
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 364
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
C++——智能指针
最新发布
Wangx_wang的博客
11-12 579
介绍了几种智能指针的不同和实现思路以及循环引用的问题
C++builder中的人工智能（15）：C++高斯误差线性单元（GELU）
caridle的专栏
11-08 707
激活函数（phi()），也称为转移函数或阈值函数，它根据净输入函数的给定值（sum）确定激活值（a = phi(sum)）。在这里，sum是它们权重中的信号之和，激活函数是这个和的新值，具有给定的函数或条件。换句话说，激活函数是将所有加权信号的和转换为该信号的新激活值的方法。有不同类型的激活函数，通常使用的是线性（恒等）、双极性和逻辑（sigmoid）函数。在C++（以及大多数编程语言）中，你可以创建自己的激活函数。注意，sum是净输入函数的结果，它计算所有加权信号的和。我们将使用这些作为输入函数的结果。
C++实现选择、插入与冒泡排序算法详解
本资源介绍了三种基本的排序算法：选择排序（Selection Sort）、插入排序（Insertion Sort）和冒泡排序（Bubble Sort），...在实际开发中，根据数据量和性能需求，会选择更高效的排序算法，如快速排序、归并排序等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值