冒泡排序详解

Posted 发着呆看星的博客

tags:

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

引入

:::tips

  • 冒泡排序顾名思义,就是像冒泡一样,泡泡在水里慢慢升上来,由小变大。
  • 虽然冒泡排序和冒泡并不完全一样,但却可以帮助我们理解冒泡排序。
    :::

思路

:::tips

  • 一组无序的数组,要求我们从小到大排列

    1. 我们可以先将最大的元素放在数组末尾
    2. 再将第二大的数放在数组的倒数第二个位置
    3. 再将第三大的数放在数组的倒数第三个位置
    4. 以此类推
  • 那么现在问题的关键就是如何将 第 n 大的数 放在 倒数第 n 个位置 ---> 交换
    :::

  • 下面是冒泡排序的gif动画,该图来自于菜鸟教程

实现

提醒
:::tips

  • 现在我们假设无序数组长度为 n 即下标 [ 0 , n-1 ]

  • 当前元素下标为 i ,下一个元素的下标为 j
    :::
    第一次遍历 [ 0 , n - 1- 1 ] ---> [ 0 , n -2 ]
    :::tips

  • 如果 当前元素 > 后一个元素 ,那么就交换两个元素 , 再进行下次遍历

  • 如果 当前元素 > 后一个元素 , 直接进行下次遍历

  • 直到遍历完成之后,最大的值就在一次一次的交换中被交换到了数组末尾

  • 思考:为什么是从 0 开始遍历 ,n-2 结束 ?

    1. 因为 j 为 i 的下一个元素下标 ,如果为 [ 0,n-1 ]的话 ,那么当前元素下标就可以为 n - 1,那么下一个元素的下标就为 n ,显然数组下标越界了
    2. 而且正因为是从 [ 0 , n -2] 范围遍历 ,刚好可以保证经过这一轮遍历后 ,最大的数在数组末尾 ( i = n - 2 【即为倒数第二个数】 ,j = i + 1【末尾数】)
      :::
      第二次遍历 [ 0 , n - 1- 2]----> [ 0 , n -3 ]

:::tips

  • 经过第一次遍历,我们已经将最大的数移动到了数组末尾,所以,我们不用在去对末尾以确定的数进行比较,我们可以减少次数,来提高效率
  • 再次引用第一次遍历的步骤
    :::

......
最后一次遍历 [ 0 , n - 1 - (n-1) ] ---- > [ 0 , 0 ]
:::tips

  • 最后一次遍历的情况就是还剩下两个元素未进行排序的情况 ,即下标 0 和 下标 1 未进行排序
  • 只需对这两个元素进行排序后,就完成了这个数组的排序
    :::
    怎么确定一共需要遍历几次及每次遍历的数组下标范围

:::tips

  • 遍历次数问题
    • 我们先来做一个假设
      • 如果一个数组只有两个元素,那么应该遍历几次 ? 1 次
      • 如果一个数组只有三个元素,那么应该遍历几次 ? 2次
        • 第一次将最大的数放在最末尾 ,第二次将第二大的数放在倒数第二 , 第三大的元素自然而然就在倒数第三了【即第一个】 ,不用遍历
      • 如果一个数组只有四个元素,那么应该遍历几次 ? 3 次
        • 第一次将最大的数放在最末尾 ,第二次将第二大的数放在倒数第二 , 第三次将第三大的元素放在在倒数第三 ,剩下一个元素,不用排
      • 显而易见,如果有 n 个 元素 ,那么就需要遍历 n - 1 次
  • 每次遍历数组下标
    • 按照上面的实现部分
      • 第一次遍历我们需要数组的下标为 [ 0 , n -2 ]
      • 第二次遍历我们需要数组的下标为 [ 0 , n -3 ]
      • 第三次遍历我们需要数组的下标为 [ 0 , n -4 ]
    • 那么就有一个规律了 ,n - 2 , n - 3 , n - 4
      • 当我们正在进行第一次遍历时,用一个变量保存 m = 1 , 那么第一次遍历下标可以为 [ 0 , n -1 - m ]
      • 当我们正在进行第二次遍历时,用一个变量保存 m = 2 , 那么第一次遍历下标可以为 [ 0 , n -1 - m ]
      • 当我们正在进行第三次遍历时,用一个变量保存 m = 3 , 那么第一次遍历下标可以为 [ 0 , n -1 - m ]
      • 当我们正在进行最后一次遍历时,用一个变量保存 m = n - 1, 那么第一次遍历下标可以为 [ 0 , n -1 - m ] ---> [ 0 , n - 1 - (n -1) ]
        :::

代码实现

// 冒泡排序算法
public static int[] bubble(int[] ints)
    // 注意我这里使用的是 <  , 而不是我思路中的  <= , 可以自行更改 ,如果没想明白说明你还没有理解
    // 用 i 来表示一共需要遍历多少次
    for (int i = 0; i < ints.length-1; i++) 
        // 真正开始进行遍历 ,根据 i 的值 不同 ,j 就不同 ,也就是说每次大遍历中小遍历的次数不同
        for (int j = 0; j < ints.length-1-i; j++) 
            // 如果前一个元素 >  后一个元素 ,则交换
            if (ints[j] > ints[j+1])
                int temp = ints[j];
                ints[j] = ints[j+1];
                ints[j+1] = temp;
            
            // 继续下次遍历
        
    
    return ints;

视频+图文+动画详解冒泡排序

点击蓝字关注小乔

 

从Java初级到进阶一起学起来

 


详解冒泡排序







 目录 

01

视频讲解冒泡排序(点击最下方“阅读原文”可去B站观看视频)

02

冒泡排序的思想

03

冒泡排序的动画演示及思路分析

04

冒泡排序的代码+代码优化+代码详解


一、视频讲解冒泡排序


思路分析:




代码及代码优化:




二、冒泡排序的思想


从前到后(即从下标较小的元素开始依次比较相邻元素的值,若发现逆序交换位置,使值较大的元素逐渐从前移向后部


以7,3,22,15,8为例

根据冒泡排序的思想:

首先我们应该比较7和3是否逆序
逆序交换这2个数的位置

因为7>3,它们的位置是逆序的。故交换位置
交换后:7,3, 22,15,8   ⇒  3,7,22,15,8

比较7和22是否逆序
逆序交换这2个数的位置

因为7<22,它们的位置是顺序的。故不用交换位置
顺序仍为:3,7,22, 15,8   ⇒  3,7,22, 15,8

以此类推,思路分析会进行详细分析。


三、冒泡排序的动画演示及思路分析


动画演示:


可视化网站网址:https://visualgo.net/en



思路分析

第一轮排序:22的位置被固定


7和3比较,若逆序则交换位置。

因为7>3两数是逆序的,所以交换位置:
7,3, 22,15,8   ⇒  3,7, 22,15,8


7和22比较,若逆序则交换位置。

因为7<22两数是顺序的,所以不交换位置:
3, 7, 22, 15,8   ⇒   3, 7, 22, 15,8


22和15比较,若逆序则交换位置。

因为22>15两数是逆序的,所以交换位置:
3,7, 22,15, 8   ⇒   3,7, 15,22, 8


22和8比较,若逆序则交换位置。

因为22>8两数是逆序的,所以交换位置:
3,7, 15, 22,8   ⇒  3,7, 15, 8,22


第一轮排序后的结果:

【22的位置被固定】3,7, 15, 8,22

第二轮排序:15的位置被固定


3和7比较若逆序则交换位置。

因为3<7两数是顺序的,所以不交换位置:
3,7, 15, 8,22   ⇒   3,7, 15, 8,22


7和15比较若逆序则交换位置。

因为7<15两数是顺序的,所以不交换位置:
3, 7, 15, 8,22   ⇒   3, 7, 15, 8,22


15和8比较若逆序则交换位置。

因为15>8两数是逆序的,所以交换位置:
3, 7, 15, 822   ⇒   3, 7, 8, 1522


第二轮排序后的结果:

【15的位置被固定】3, 7, 8, 15, 22

第三轮排序:8的位置被固定

3和7比较若逆序则交换位置。

因为3<7两数是顺序的,所以不交换位置:
3,7, 8, 15,22   ⇒   3,7, 8, 15,22


7和8比较若逆序则交换位置。

因为7<8两数是顺序的,所以不交换位置:
3, 7, 8, 15,22  ⇒   3, 7, 8, 15,22


第三轮排序后的结果:

【8的位置被固定】:3, 7, 8,15, 22

第四轮排序:7的位置被固定

3和7比较若逆序则交换位置。

因为3<7两数是顺序的,所以不交换位置:
3,78,15,22   ⇒   3,7, 8,15,22


第四轮排序后的结果:

【7的位置被固定】:3, 7, 8,15, 22


排序到此结束


思路总结 :

以上面的5个数为例,我们看到5个数进行排序需要进行4轮大的排序
那么n个数排序时,需要进行 (n-1) 轮大的排序。

(1)上面五个数的第 一轮排序需进行4次(5个数参与排序,数组下标0-4
(2)上面五个数的第轮排序需进行3次(4个数参与排序,数组下标0-3
(3)上面五个数的第轮排序需进行2次(3个数参与排序,数组下标0-2
(4)上面五个数的第轮排序需进行 1次(2个数参与排序,数组下标0-1


四、冒泡排序的代码+代码优化+代码详解


代码—多个for循环:


代码:




package Sort;
import java.util.Arrays;
public class BubbleSort {
// 原始数组:7,3,22,15,8数组长度为5
public static void bubbleSort(int arr[]) {// 用此方法给数组进行排序 int i = 0, temp = 0;// temp变量用来保存arr[i]和arr[i+1]中的大数 // 第一趟排序 for (i = 0; i < arr.length-1-0; i++) {//i<5 下标是0-4//(需arr.length-1-0。因为如果只是arr.length那么当i=4时,arr[i+1]=5,不满足i<5的条件,数组会越界) if (arr[i] > arr[i + 1]) {// 如果两个数是逆序的,就交换位置 temp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = temp; } System.out.println("第一次排序"+Arrays.toString(arr)); }
// 第二趟排序 for (i = 0; i < arr.length-1-1; i++) {//i<4 下标是0-3, 22的位置已经确定//(需arr.length-1-1。因为如果只是arr.length-1那么当i=3时,arr[i+1]=4,不满足i<4的条件数组会越界) if (arr[i] > arr[i + 1]) {// 如果两个数是逆序的,就交换位置 temp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = temp; } System.out.println("第二次排序"+Arrays.toString(arr)); } // 第三趟排序 for (i = 0; i < arr.length-1-1-1; i++) {//i<3 下标是0-2 22、15的位置已经确定//(需arr.length-1-1-1。因为如果只是arr.length-1-1那么当i=2时,arr[i+1]=3,不满足i<3的条件数组会越界) if (arr[i] > arr[i + 1]) {// 如果两个数是逆序的,就交换位置 temp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = temp; } System.out.println("第三次排序"+Arrays.toString(arr)); } // 第四趟排序 for (i = 0; i < arr.length-1-1-1-1; i++) {//i<2 下标是0-1 22、15、8的位置已经确定 //(需arr.length-1-1-1-1。因为如果只是arr.length-1-1-1那么当i=1时,arr[i+1]=2,不满足i<2的条件数组会越界) if (arr[i] > arr[i + 1]) {// 如果两个数是逆序的,就交换位置 temp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = temp; } System.out.println("第四次排序"+Arrays.toString(arr)); } }
public static void main(String[] args) { int arr[] = { 7, 3, 22, 15, 8 }; bubbleSort(arr); }
}


结果:




【视频+图文+动画】详解冒泡排序


代码优化1—两个for循环嵌套:


优化分析:



轮排序:i<arr.length-1-0
轮排序:i<arr.length-1-1
轮排序:i<arr.length-1-1-1
轮排序:i<arr.length-1-1-1-1


所以可以用一个for循环嵌套在我们刚刚的for循环上


这个变量j的范围是0-3j < arr.length - 1


arr.length=5,j<arr.length,j的范围[0-4]

j<arr.length-1,j的范围[0-3]


代码:




package Sort;
import java.util.Arrays;
public class BubbleSort {
// 原始数组:7,3,22,15,8数组长度为5
public static void bubbleSort(int arr[]) {// 用此方法给数组进行排序 int i = 0, temp = 0;// temp变量用来保存大数 int j = 0; for (j = 0; j < arr.length - 1; j++) { for (i = 0; i < arr.length - 1 - j; i++) {// i<5 下标是0-4 if (arr[i] > arr[i + 1]) {// 如果两个数是逆序的,就交换位置 temp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = temp; } } System.out.println("第" + (j + 1) + "次排序" + Arrays.toString(arr)); } }
public static void main(String[] args) { int arr[] = { 7, 3, 22, 15, 8 }; bubbleSort(arr); }}


结果:




【视频+图文+动画】详解冒泡排序


代码优化2—两个for循环嵌套+flag标志:


优化分析:




其实当第二轮排序完成后,数组已经是有序的。
没有一个标志去告诉for循环数组已经有序该退出for循环了。


所以针对这个问题:定义一个boolean flag = false;

判断是否结束for循环


如果flag == false

说明数组已经有序,可以退出for循环


如果flag == true,我们需要让flag=false;

以便下次数组有序时,可以退出for循环。


代码:




package Sort;
import java.util.Arrays;
public class BubbleSort {
// 原始数组:7,3,22,15,8数组长度为5
public static void bubbleSort(int arr[]) {// 用此方法给数组进行排序 int i = 0, temp = 0;// temp变量用来保存大数 int j = 0; boolean flag = false; for (j = 0; j < arr.length - 1; j++) { for (i = 0; i < arr.length - 1 - j; i++) {// i<5 下标是0-4 if (arr[i] > arr[i + 1]) {// 如果两个数是逆序的,就交换位置 flag = true;//flag为true说明两数逆序,需要交换位置 temp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = temp; } } if(flag==false) {//第二个for循环每循环一轮后进行比较,说明数组已经是有序的了可以退出循环了,整个for循环结束 break; }else { flag=false;//如果不满足flag==false的条件,就说明数组的两数之间发生了交换, // flag的值为true,为了优化,需要将flag再置为false } System.out.println("第" + (j + 1) + "次排序" + Arrays.toString(arr)); }} public static void main(String[] args) { int arr[] = { 7, 3, 22, 15, 8 }; bubbleSort(arr); }
}


结果:




【视频+图文+动画】详解冒泡排序


代码详解:(优化版本2)


以7,3,22,15,8为例:

第一轮排序:22的位置被固定


7和3比较,若逆序则交换位置。

因为7>3两数是逆序的,所以交换位置:

flag==true

7,3, 22,15,8   ⇒  3,7, 22,15,8


7和22比较,若逆序则交换位置。

因为7<22两数是顺序的,所以不交换位置:

flag=false(第一轮排序完成后才判断flag的值)
3, 7, 22, 15,8   ⇒   3, 7, 22, 15,8


22和15比较,若逆序则交换位置。

因为22>15两数是逆序的,所以交换位置:

flag==true

3,7, 22,15, 8   ⇒   3,7, 15,22, 8


22和8比较,若逆序则交换位置。

因为22>8两数是逆序的,所以交换位置:

flag==true

3,7, 15, 22,8   ⇒  3,7, 15, 8,22


第一轮排序后flag==ture满足

else {flag=false;//如果不满足flag==false的条件,就说明数组的两数之间发生了交换,//flag的值为true,为了优化,需要将flag再置为false }

所以flag=false,再开始第二轮排序

【22的位置被固定】3,7, 15, 8,22

第二轮排序:15的位置被固定


3和7比较若逆序则交换位置。

因为3<7两数是顺序的,所以不交换位置:

flag==true

3,7, 15, 8,22   ⇒   3,7, 15, 8,22


7和15比较若逆序则交换位置。

因为7<15两数是顺序的,所以不交换位置:

flag==true

3, 7, 15, 8,22   ⇒   3, 7, 15, 8,22


15和8比较若逆序则交换位置。

因为15>8两数是逆序的,所以交换位置:

flag==false(第二轮排序完成后才判断flag的值)
3, 7, 15, 822   ⇒   3, 7, 8, 1522


第二轮排序后flag==ture满足

else {flag=false;//如果不满足flag==false的条件,就说明数组的两数之间发生了交换,//flag的值为true,为了优化,需要将flag再置为false}

所以flag=false,再开始第三轮排序

【15的位置被固定】3, 7, 8, 15, 22

第三轮排序:8的位置被固定

3和7比较若逆序则交换位置。

因为3<7两数是顺序的,所以不交换位置:

flag==false(第三轮排序完成后才判断flag的值)

3,7, 8, 15,22   ⇒   3,7, 8, 15,22


7和8比较若逆序则交换位置。

因为7<8两数是顺序的,所以不交换位置:

flag==false(第三轮排序完成后才判断flag的值)

3, 7, 8, 15,22  ⇒   3, 7, 8, 15,22


第三轮排序后flag==false满足

if(flag==false) {//第二个for循环每循环一轮后进行比较,说明数组已经是有序的了可以退出循环了,整个for循环结束break;}

所以退出第一个for循环,结束数组排序

输出排序后的结果。


结果:




【视频+图文+动画】详解冒泡排序


到此冒泡排序讲解就结束啦~~


【视频+图文+动画】详解冒泡排序

点“阅读原文”去B站看讲解视频

点“在看”给我一朵小黄花【视频+图文+动画】详解冒泡排序

【视频+图文+动画】详解冒泡排序

欢迎大家来公号 

“小乔的编程内容分享站” 

来找小乔玩~
一起学习Java基础+算法~
还有更多资源等你来拿哦~

长按关注小乔

以上是关于冒泡排序详解的主要内容,如果未能解决你的问题,请参考以下文章

冒泡排序详解

Java之冒泡排序详解

冒泡排序算法详解

冒泡排序详解

冒泡排序及优化详解

冒泡排序算法,C语言冒泡排序算法详解