（浅入浅出）小白学习冒泡排序（c++版）

零一零（互联网小白版）

已于 2024-08-28 15:42:25 修改

阅读量538

点赞数 17

分类专栏：浅入浅出文章标签： c++ 排序算法经验分享

于 2024-08-26 19:21:37 首次发布

本文链接：https://blog.csdn.net/qq_45233816/article/details/141555066

版权

浅入浅出专栏收录该内容

4 篇文章 0 订阅

订阅专栏

浅入浅出之小白学习冒泡排序！！

码字不易，如果觉得讲的好请一键三连！！

如果有错误，请指出，大家共同进步！！！

1. 思想

主要思想：一轮“固定”一个元素的最终位置。（一定要带着这个思想读下面的）
基本思想：给定一组排序序列，从前向后依次对相邻两个元素的值比较，将较大的数放到前面。这样，每一轮过后，都有这一轮的最大值移动到了这一轮的最前面。

2. 例子

单看定义可能有些复杂，我用一个例子来做具体说明

待排序数组：[8, 18, 5, 9, 4, 10, 1]

第一轮排序：（紫色代表确定了最终的位置，红色表示当前排序的结果）

（1）8， 18， 5， 9， 4， 10， 1

（2）8， 5， 18， 9， 4， 10， 1

（3）8， 5， 9， 18， 4， 10， 1

（4）8， 5， 9， 4， 18， 10， 1

（5）8， 5， 9， 4， 10， 18， 1

（6）8， 5， 9， 4， 10， 1， 18

第二轮排序：（此时18已固定）

（1）5， 8， 9， 4， 10， 1， 18

（2）5， 8， 9， 4， 10， 1， 18

（3）5， 8， 4， 9， 10， 1， 18

（4）5， 8， 4， 9， 10， 1， 18

（5）5， 8， 4， 9， 1， 10， 18

第三轮排序：（此时10，18已固定）

（1）5， 8， 4， 9， 1， 10， 18

（2）5， 4， 8， 9， 1， 10， 18

（3）5， 4， 8， 9， 1， 10， 18

（4）5， 4， 8， 1， 9， 10， 18

第四轮排序：（此时9，10，18已固定）

（1）4， 5， 8， 1， 9， 10， 18

（2）4， 5， 8， 1， 9， 10， 18

（3）4， 5， 1， 8， 9， 10， 18

第五轮排序：（此时8，9，10，18已固定）

（1）4， 5， 1， 8， 9， 10， 18

（2）4，1， 5， 8， 9， 10， 18

第六轮排序：（因为后五个已经固定，只剩前两个还没有排序，所以只需要比较前两个即可）

（1）1， 4， 5， 8， 9， 10， 18

3. 分析

注意看红色的元素，就像从海底升起的泡泡一样，不断地往前（然后两两比较），所以叫冒泡排序。
原谅我手欠，写了七个元素，排了六轮。
那么通过上面这个吐槽，我们不难发现，如果有n个元素，需要排列（n-1）轮，因为最后一轮虽然还剩两个没有拍好，但是只需要比较这两个，就能固定出两个元素的位置，其他轮都是固定一个元素的位置，最后一轮固定了两个，所以就（n-1）轮。
每一轮的比较次数，逐轮减少。一轮固定一个，你都固定了，肯定就少比较了一次，因为需要比较的元素减少了一。

4. 代码

理解了上面，再来看代码，就十分简单了。

#include <iostream>
#include <vector>

void bubble_sort(std::vector<int>& arr) {
    int n = arr.size();  // 调用.size()计算数组元素个数

    //这里n-1，在第三节分析里不是说一共是n-1轮吗，然后这里i=0，i<n-1，也就意味着i从0到n-2，算上正好n-1轮
    for (int i = 0; i < n - 1; ++i) {

        //这里n-i-1，也正好对应每一轮"固定一个元素"这个思想，以i=1举例，此时说明第一轮已经成功了，固定了一个最大值，所以这里j-"1"-1，说明最后一个元素已经被"固定"了。
        //同样也可以用边界条件来理解，还是i=1，假如j=n-3<j-"1"-1, 依然可以进入循环，然后比较arr[n-3]与arr[n-2]的元素大小，这已经是j的最大值，所以不可能比较arr[n-1]了。
        //从这个边界值也能看出，"一轮固定一个的思想"。
        for (int j = 0; j < n - i - 1; ++j) {
            if (arr[j] > arr[j + 1]) {
                std::swap(arr[j], arr[j + 1]);
            }
        }
    }
}

int main() {
    std::vector<int> arr = {8, 18, 5, 9, 4, 10, 1};
    bubble_sort(arr);
    std::cout << "排序后的数组: ";
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}

5. 如何优化

请各位思考这样一个问题，如果数组本来就是升序的，那么会发生什么？

答: 在第一轮的时候没有发生任何元素交换。也就是说，当没有发生任何元素交换的时候，数组已经排序完毕。

基于这个思想就有了如下的代码，这里只写bubble_sort函数，主函数一样的。

void bubble_sort(std::vector<int>& arr) {
    int n = arr.size();

    for (int i = 0; i < n - 1; ++i) {
        bool swapped = false;  // 添加一个布尔标志来检查是否发生了交换

        for (int j = 0; j < n - i - 1; ++j) {
            if (arr[j] > arr[j + 1]) {
                std::swap(arr[j], arr[j + 1]);
                swapped = true;  // 如果发生交换，则设置标志为true
            }
        }

        // 如果没有发生交换，提前退出循环
        if (!swapped) {
            break;
        }
    }
}