❤️「 冒泡排序 」中的 「 算法思维 」❤️

Posted 英雄哪里出来

tags:

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

零、📃前言

  想要养成 「算法思维」,每一个简单的问题都要思考它背后的真正含义,做到 举一反三,触类旁通。
  「 冒泡排序 」 是最好理解且编码最简单的排序算法,所以一般各种 「数据结构」 的教科书上都会一并进行讲解。于是,我也来讲一讲。我会尽量做到「深入浅出」,让 90%「零基础小白 」 也都能理解,真正做到 「让天下没有难学的算法」 。我知道这很难,但是我愿意尝试!我用我最好的青春,写下了这篇文章。

🙉饭不食,水不饮,题必须刷🙉

C语言免费动漫教程,和我一起打卡!
🌞《光天化日学C语言》🌞

LeetCode 太难?先看简单题!
🧡《C语言入门100例》🧡

数据结构难?不存在的!
🌳《数据结构入门》🌳

LeetCode 太简单?算法学起来!
🌌《夜深人静写算法》🌌

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

一、🎯简单释义

1、算法目的

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

2、算法思想

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

3、命名由来

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

二、🧡核心思想

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

三、🔆动图演示

1、样例

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

图二-1-1

2、算法演示

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

图二-2-1

3、样例说明

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

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

四、🌳算法前置

1、循环的实现

  • 这个算法本身需要做一些「 循环 」进行迭代计算,所以你至少需要知道「 循环 」 的含义,这里以 「 c++ 」 为例,来看下一个简单的「 循环 」是怎么写的。代码如下:
int n = 520;
for(int i = 0; i < n; ++i) {
    // 循环体
}
  • 这个语句就是一个最简单的循环语句,它会将循环体内的语句执行 n n n 次,而这里的 n n n 等于 520 520 520,也就是会执行 520 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 a a b b b,两个杯子里都盛满了水,现在想把两个杯子里的水「交换」一下,那么第一个想到的方法是什么?

当然是再找来一个临时杯子:
  1)先把 a a a 杯子的水倒进这个临时的杯子里;
  2)再把 b b b 杯子的水倒进 a a a 杯子里;
  3)最后把临时杯子里的水倒进 b b b 杯子;

  • 这种就是临时变量法。以 「 c++ 」 为例,实现如下:
#define Type int
void swap(Type* a, Type* b) {
    Type tmp = *a;     // 把 a 杯子的水倒进临时杯子
    *a = *b;           // 把 b 杯子的水倒进 a 杯子
    *b = tmp;          // 把 临时杯子 的水 倒进 b 杯子
}
  • 这里*涉及到的「指针」相关知识,属于语法层面,请自行学习。

五、🥦算法描述

1、问题描述

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

2、算法过程

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

六、🧶算法分析

1、时间复杂度

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

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

  • 因此,总「比较」次数如下:
  • ( n − 1 ) + ( n − 2 ) + . . . + 1 + 0 = n ( n − 1 ) 2 (n-1) + (n-2) + ... + 1 + 0 = \\frac {n(n-1)}{2} (n1)+(n2)+...+1+0=2n(n1)
  • 总的时间复杂度为: O ( n 2 ) O(n^2) O(n2)

2、空间复杂度

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

七、🧢优化方案

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

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

八、💙代码实践

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

九、💗代码验证

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

🙉好了,今天的内容就到这里了,你学废了吗?!🙉

🙉饭不食,水不饮,题必须刷🙉

C语言免费动漫教程,和我一起打卡!
🌞《光天化日学C语言》🌞

LeetCode 太难?先看简单题!
🧡《C语言入门100例》🧡

数据结构难?不存在的!
🌳《数据结构入门》🌳

LeetCode 太简单?算法学起来!
🌌《夜深人静写算法》🌌

以上是关于❤️「 冒泡排序 」中的 「 算法思维 」❤️的主要内容,如果未能解决你的问题,请参考以下文章

❤️数据结构入门❤️(4 - 1)- 冒泡排序

❤️十大排序算法详解❤️——可能是你看过最全的,完整版代码

JavaScript之算法设计思想

❤️五万字《十大排序算法》动图讲解❤️(建议收藏)

❤️五万字《十大排序算法》动图讲解❤️(建议收藏)

Java 数据结构 & 算法宁可累死自己, 也要卷死别人 20 排序算法