❤️万字详解「冒泡排序」，深入浅出「算法思维」❤️

Posted 2021-08-21 英雄哪里出来

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了❤️万字详解「冒泡排序」，深入浅出「算法思维」❤️相关的知识，希望对你有一定的参考价值。

文章目录

零、📃前言
一、🎯简单释义
二、🧡核心思想
三、🔆动图演示
四、🌳算法前置
五、🥦算法描述
六、🧶算法分析
七、🧢优化方案
八、💙代码实践
九、💗代码验证

零、📃前言

「冒泡排序」 是最好理解且编码最简单的排序算法，所以一般各种 「数据结构」 的教科书上都会一并进行讲解。于是，我也来讲一讲。我会尽量做到「深入浅出」，让 90% 的 「零基础小白」 也都能理解，真正做到 「让天下没有难学的算法」 。我知道这很难，但是我愿意尝试！我用我最好的青春，写下了这篇文章。

🙉饭不食，水不饮，题必须刷🙉
C语言免费动漫教程，和我一起打卡！ 🌞《光天化日学C语言》🌞
LeetCode 太难？先看简单题！ 🧡《C语言入门100例》🧡
数据结构难？不存在的！ 🌳《数据结构入门》🌳
LeetCode 太简单？算法学起来！ 🌌《夜深人静写算法》🌌

那么，我的教程和别人的教程有什么不同的地方呢？
「第一步」简单释义：我会解释一下这个算法的目的、思想、以及为什么叫这个名字以帮助记忆。
「第二步」核心思想：大致介绍一下这个算法的核心思想。
「第三步」动图演示：引入一个动图，并且用一个切实的例子展示一下算法执行的全过程。
「第四步」算法前置：在学习这个算法之前，我们需要学习的前置内容有哪些？这些内容是需要事先去攻克的。
「第五步」算法描述：细致的讲解整个算法的执行流程。
「第六步」算法分析：对算法的时间复杂度和空间复杂度进行一个详细的分析。
「第七步」优化方案：介绍一些可以优化的点。
「第八步」代码实践：用 C/C++ 来实现上述算法。
「第九步」代码验证：推荐一些比较好用的在线评测系统来验证我们实现的算法的正确性。

一、🎯简单释义

1、算法目的

将原本乱序的数组变成有序，可以是 「升序」 或者 「降序」 （为了描述统一，本文一律只讨论 「升序」 的情况）。

2、算法思想

通过不断比较相邻的元素，如果「左边的元素」 大于 「右边的元素」，则进行「交换」，直到所有相邻元素都保持升序，则算法结束。

3、命名由来

数值大的元素经过交换，不断到达数组的尾部，就像气泡，逐渐浮出水面一样，故此命名 「冒泡排序」 。

二、🧡核心思想

「迭代」：类似的事情，不停地做。
「比较」：关系运算符大于( $\\gt$ ) 的运用。
「交换」：变量或者对象的值的互换。

三、🔆动图演示

1、样例


8	5	6	4	3	7	10	2

初始情况下的数据如 图二-1-1 所示，基本属于乱序，纯随机出来的数据。

图二-1-1

2、算法演示

接下来，我们来看下排序过程的动画演示。如 图二-2-1 所示：

图二-2-1

3、样例说明

图示	含义
■ 的柱形	代表尚未排好序的数
■ 的柱形	代表正在执行比较的两个数
■ 的柱形	代表已经排好序的数

我们看到，首先需要将 「第一个元素」 和 「第二个元素」 进行 「比较」，如果前者大于后者，则进行 「交换」，然后再比较 「第二个元素」 和 「第三个元素」 ，以此类推，直到 「最大的那个元素」 被移动到 「最后的位置」 。
然后，进行第二轮「比较」，直到 「次大的那个元素」 被移动到 「倒数第二的位置」 。
最后，经过一定轮次的「比较」 和 「交换」之后，一定可以保证所有元素都是 「升序」 排列的。

四、🌳算法前置

1、循环的实现

这个算法本身需要做一些「循环」进行迭代计算，所以你至少需要知道「循环」 的含义，这里以 「 c++ 」 为例，来看下一个简单的「循环」是怎么写的。代码如下：

int n = 520;
for(int i = 0; i < n; ++i) {
    // 循环体
}

这个语句就是一个最简单的循环语句，它会将循环体内的语句执行 $n$ 次，而这里的 $n$ 等于 $520$ ，也就是会执行 $520$ 次。
具体的语法细节不是本文的主要内容，请自行学习。

2、比较的实现

「比较」两个元素的大小，可以采用关系运算符，本文我们需要排序的数组是按照 「升序」 排列的，所以用到的关系运算符是 「大于运算符（即 >）」 。
我们可以将两个数的「比较」写成一个函数isBigger，以 「 c++ 」 为例，实现如下：

#define Type int
bool isBigger(Type a, Type b) {
    return a > b;
}

其中Type代表数组元素的类型，可以是整数，也可以是浮点数，也可以是一个类的实例，这里我们统一用int来讲解，即 32位有符号整型。

3、交换的实现

所谓「交换」，就是对于两个变量，将它们的值进行互换。
在 「Python」 中，我们可以直接写出下面这样的代码就实现了变量的交换。

a, b = b, a

在 「 c++ 」 里，这个语法是错误的。
我们可以这么理解，你有两个杯子 $a$ 和 $b$ ，两个杯子里都盛满了水，现在想把两个杯子里的水「交换」一下，那么第一个想到的方法是什么？

当然是再找来一个临时杯子：
1）先把 $a$ 杯子的水倒进这个临时的杯子里；
2）再把 $b$ 杯子的水倒进 $a$ 杯子里；
3）最后把临时杯子里的水倒进 $b$ 杯子；

这种就是临时变量法。以 「 c++ 」 为例，实现如下：

#define Type int
void swap(Type* a, Type* b) {
    Type tmp = *a;     // 把 a 杯子的水倒进临时杯子
    *a = *b;           // 把 b 杯子的水倒进 a 杯子
    *b = tmp;          // 把 临时杯子 的水 倒进 b 杯子
}

这里*涉及到的「指针」相关知识，属于语法层面，请自行学习。

五、🥦算法描述

1、问题描述

给定一个 $n$ 个元素的数组，数组下标从 $0$ 开始，采用「冒泡排序」将数组按照 「升序」排列。

2、算法过程

整个算法的执行过程分以下几步：
1）循环迭代变量 $\\to n-1$ ；
2）每次迭代，令 $j = i$ ，循环执行比较 $a [j]$ 和 $a [j + 1]$ ，如果产生 $\\gt a[j+1]$ 则交换两者的值。然后执行 $j = j + 1$ ，这时候对 $j$ 进行判断，如果 $\\ge n-1$ ，则回到 1），否则继续执行 2）。

六、🧶算法分析

1、时间复杂度

我们假设 「比较」 和 「交换」 的时间复杂度为 $O (1)$ （为什么这里说假设，因为有可能要「比较」的两个元素本身是数组，并且是不定长的，所以只有当系统内置类型，我们才能说这两个操作是 $O (1)$ 的）。
「冒泡排序」 中有两个嵌套循环。

外循环正好运行 $n - 1$ 次迭代。但内部循环运行变得越来越短：
当 $i = 0$ ，内层循环 $n - 1$ 次「比较」操作。
当 $i = 1$ ，内层循环 $n - 2$ 次「比较」操作。
当 $i = 2$ ，内层循环 $n - 3$ 次「比较」操作。
……
当 $i = n - 2$ ，内层循环 $1$ 次「比较」操作。
当 $i = n - 1$ ，内层循环 $0$ 次「比较」操作。

因此，总「比较」次数如下：
$\\frac {n(n-1)}{2}$
总的时间复杂度为： $O(n^2)$

2、空间复杂度

由于算法在执行过程中，只有「交换」变量时候采用了临时变量的方式，而其它没有采用任何的额外空间，所以空间复杂度为 $O (1)$ 。

七、🧢优化方案

「冒泡排序」在众多排序算法中效率较低，时间复杂度为 $O(n^2)$ 。
想象一下，当有 $n = 10^5$ 个数字。即使我们的计算机速度超快，并且可以在 1 秒内计算 $10^8$ 次操作，但冒泡排序仍需要大约一百秒才能完成。
但是，它的外层循环是可以提前终止的，例如，假设一开始所有数字都是升序的，那么在首轮「比较」的时候没有发生任何的「交换」，那么后面也就不需要继续进行 「比较」 了，直接跳出外层循环，算法提前终止。

「改进思路」如果我们通过内部循环完全不交换，这意味着数组已经排好序，我们可以在这个点上停止算法。

八、💙代码实践

#include <stdio.h>

int a[1010];

void input(int n, int *a) {
    for(int i = 0; i < n; ++i) {
        scanf("%d", &a[i]);
    }
}

void output(int n, int *a) {
    for(int i = 0; i < n; ++i) {
        if(i)
            printf(" ");
        printf("%d", a[i]);
    }
    puts("");
}

void swap(int *a, int *b) {
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

void BubbleSort(int n, int *a) {             // (1)
    bool swapped;
    int last = n;
    do {
        swapped = false;                     // (2)
        for(int i = 0; i < last - 1; ++i) {  // (3)
            if(a[i] > a[i+1]) {              // (4)
                swap(&a[i], &a[i+1]);        // (5)
                swapped = true;              // (6)
            }
        }
        --last;
    }while (swapped);
} 

int main() {
    int n;
    while(scanf("%d", &n) != EOF) {
        input(n, a);
        BubbleSort(n, a);
        output(n, a);
    }
    return 0;
}

$(1)$ void BubbleSort(int n, int *a)为冒泡排序的实现，代表对a[]数组进行升序排序。
$(2)$ swapped标记本轮迭代下来，是否有元素产生了交换。
$(3)$ 每次冒泡的结果，会执行last的自减，所以待排序的元素会越来越少。
$(4)$ 如果发现两个相邻元素产生逆序，则将它们进行交换。保证右边的元素一定不比左边的小。
$(5)$ swap实现了元素的交换，这里需要用&转换成地址作为传参。
$(6)$ 标记更新。一旦标记更新，则代表进行了交换，所以下次迭代必须继续。

九、💗代码验证

我写文章并不是为了推广什么网站，所以我只会告诉大家方法，具体验证方式还请自行抉择。
比如，你可以在百度上搜索 代码在线提交、OnlineJudge、HDOJ、LeetCode、洛谷、POJ 等等的关键词，然后去找对应的题目提交验证你的代码的正确性。

🙉好了，今天的内容就到这里了，你学废了吗？！🙉

🙉饭不食，水不饮，题必须刷🙉
C语言免费动漫教程，和我一起打卡！ 🌞《光天化日学C语言》🌞
LeetCode 太难？先看简单题！ 🧡《C语言入门100例》🧡
数据结构难？不存在的！ 🌳《数据结构入门》🌳
LeetCode 太简单？算法学起来！ 🌌《夜深人静写算法》🌌