java冒泡排序详细讲解

Posted 2023-04-30

依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。
　　由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。

for(int
j=0;j<=len-i-1;j++),冒泡排序比较相邻的值，也就是a[j]和a[j+1]相比较
所以这段代码从a[0]开始与后面的a[1]比较，如果a[1]小于
a[0]就换。不小于j++，a[1]和[a2]比较，以此类推，直到比到a[len-i-1]时，也就比到了最后一个数组了。上层循环就是控制数组比较的长度。 参考技术A

整个数列分成两部分：前面是无序数列，后面是有序数列

初始状态下，整个数列都是无序的，有序数列是空

如果一个数列有n个元素，则至多需要n-1趟循环才能保证数列有序

每一趟循环可以让无序数列中最大数排到最后，（也就是说有序数列的元素个数增加1）

每一趟循环都从数列的第一个元素开始进行比较，依次比较相邻的两个元素，比较到无序数列的末尾即可（而不是数列的末尾）

如果前一个大于后一个，交换

话不多说先看图！

【例】【52,41,32,69,5,73,19】 从小到大进行排序

Java代码实现—冒泡排序

目录

1、前言

2、冒泡排序

2.1 算法思路

2.2 代码实现过程：

3、代码优化

3.1 趟数优化

3.2 循环次数优化

3.3 排序完成优化

4、结语

---

1、前言

我们书接上回，接着数组中的遗留问题来讲解这节的冒泡排序，干货满满，里面还涉及到代码的优化，希望大家有所收获

2、冒泡排序

• 冒泡排序思想：给定一个数组，让数组升序 (降序) 排序。

2.1 算法思路

• 假设排升序：

1. 将数组中相邻元素从前往后依次进行比较，如果前一个元素比后一个元素大，则交换，一趟下来后最大元素就在数组的末尾。
2. 依次从上上述过程，直到数组中所有的元素都排列好。
3. 依据这个思想，我们很容易写出如下代码：

    public static void main7(String[] args) 
        int[] array = 10,5,3,7,6;
        myBubblesort(array);
        System.out.println(Arrays.toString(array));
    
    public static void myBubblesort(int[] array)
        for (int i = 0; i < array.length; i++) 
            for (int j = 0; j < array.length-1; j++) 
                if(array[j] > array[j+1])
                    int tmp = 0;
                    tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                
            
        
    

2.2 代码实现过程：

•  上述代码在我们思路清晰的情况下很容易写出，但是代码是如何实现的呢？
• 在这里我们主要关注两个点：趟数i和每次循环的次数j。

---

• 第1趟：i = 0时

        当j = 0时，此时array[0] = 10; array[1] = 5；10 > 5，所以执行array[j] = array[j+1]的交换代码（这里交换代码简写，下同），数组变为：5,10,3,7,6;

        当j = 1时，此时array[1] = 10; array[2] = 3；10 > 3，所以执行array[j] = array[j+1]的交换代码，数组变为5,3,10,7,6;

        当j = 2时，此时array[2] = 10; array[3] = 7；10>7，所以执行array[j] = array[j+1]的交换代码，数组变为5,3,7,10,6；

        当j = 3时，此时array[3] = 10; array[4] = 6；10>6，所以执行array[j] = array[j+1]的交换代码，数组变为5,3,7,6,10；

        至此第1趟的内部循环结束，我们将10这个数字排列到数组的末尾，此时j循环了4次，j = 3时停止。

        我们发现，数组中一共有5个元素，j循环了4次，那么第一个循环条件就是j <array.length - 1；如果不-1的话，j = 4的时候，那么array[j+1]就会越界，因为数组的下标就到4。 所以array.length - 1，是否就有一个条件呢？，答案是否定的（可以做代码优化），我们继续向下执行第2趟。

•  第2趟：i = 1时

        当j = 0时，此时数组是上一趟结束的数组5,3,7,6,10，此时array[0] = 5; array[1] = 3；5 > 3，所以执行array[j] = array[j+1]的交换代码，数组变为：3,5,7,6,10;

        当j = 1时，此时array[1] = 5; array[2] = 7；5 < 7，所以不执行array[j] = array[j+1]的交换代码，数组还是3,5,7,6,10;

        当j = 2时，此时array[2] = 7; array[3] = 6；7 > 6，所以执行array[j] = array[j+1]的交换代码，数组变为3,5,6,7,10;

        至此第2趟代码就执行完交换了，因为当j = 3的时候，我们比较的是7和10的大小，在第一趟的时候，我们就已经操作完10到数组的末尾了，所以没必要再比较一次。

         在第2趟中我们将7操作到倒数第二位的指定位置，我们发现内部循环j执行了3次，到j = 2时候停止。 其实到第2趟的时候我们已经排序完成了，但是代码不知道这个事情（这点记下来，可以做代码优化），我们接着执行第3趟

•  第3趟：i = 2时

        当j = 0时，此时数组是上一趟结束的数组3,5,6,7,10，此时array[0] = 3; array[1] = 5；3 < 5，所以不执行array[j] = array[j+1]的交换代码，数组还是3,5,6,7,10。

         当j = 1时，此时array[1] = 5; array[2] = 6；5 < 6，所以不执行array[j] = array[j+1]的交换代码，数组还是3,5,6,7,10。

         至此第3趟的内部循环就结束了，因为如果再往下执行，就要操作7了，但是7我们在第2趟的时候已经操作过了。

         在第3趟的内部循环中，是操作了6在倒数第3位的位置，我们发现内部循环j执行了2次，到j = 1时候停止。 数据早就排序好了，但是代码不知道，所以继续第4趟。

• 第4趟，i = 3时

        当j = 0时，此时数组是上一趟结束的数组3,5,6,7,10，此时array[0] = 3; array[1] = 5；3 < 5，所以不执行array[j] = array[j+1]的交换代码，数组还是3,5,6,7,10。

        至此第4趟结束了，因为我们要操作的是5这个数字，和3比较完之后，就已经在原来正确的位置了，所以循环结束。

        在第4趟的内部循环中，是操作了5在倒数第4位的位置，我们发现内部循环j执行了1次，到j = 0时候停止。

         注意：我们要不要执行第5趟呢，这个问题放在代码优化中讲解。

3、代码优化

3.1 趟数优化

• 书接上一节，当我们执行完第四趟的时候，现在只有3一个数字，没有必要再执行一趟，因为其他的数字如果排序完成之后，3自动排序好了，所以趟数可以优化为：i < array.length - 1趟，也就是最后1趟没有必要执行，代码优化如下：

    public static void main7(String[] args) 
        int[] array = 10,5,3,7,6;
        myBubblesort(array);
        System.out.println(Arrays.toString(array));
    
    public static void myBubblesort(int[] array)
        for (int i = 0; i < array.length-1; i++) 
            for (int j = 0; j < array.length-1; j++) 
                if(array[j] > array[j+1])
                    int tmp = 0;
                    tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                
            
        
    

3.2 循环次数优化

• 我们发现，第1趟时候，j = 3结束循环；第2趟的时候，j = 2的时候结束循环；第3趟的时候，j = 1结束循环；第4趟的时候，j = 0结束循环。 所以内部循环j可以优化成j < array.length- 1 - i；循环次数减少，代码的运行效率就提高了。代码优化如下：

    public static void main7(String[] args) 
        int[] array = 10,5,3,7,6;
        myBubblesort(array);
        System.out.println(Arrays.toString(array));
    
    public static void myBubblesort(int[] array)
        for (int i = 0; i < array.length-1; i++) 
            for (int j = 0; j < array.length-i-1; j++) 
                if(array[j] > array[j+1])
                    int tmp = 0;
                    tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                
            
        
    

3.3 排序完成优化

• 在上述代码中，我们肉眼可见的第2趟的时候就已经排序完成，但是代码并不知道排序完成，还是会继续执行，那么我们有没有办法让代码知道什么时候已经排序完成呢？
• 我们设置一个标志位flg = false；如果执行交换代码，就把flg = true；如果没有交换代码，就证明排序已经完成。 我们在每一趟，执行或不执行交换代码的后面判断这个标志位，如果flg = true，证明本趟交换了数据，那就执行下一趟；如果flg = false；证明没有执行交换代码，那么本趟就已经排序完成了，就return结束函数即可。 代码优化如下：

   public static void main7(String[] args) 
        int[] array = 10,5,3,7,6;
        myBubblesort(array);
        System.out.println(Arrays.toString(array));
    
    public static void myBubblesort(int[] array)
        for (int i = 0; i < array.length-1; i++) 
            boolean flg = false;
            for (int j = 0; j < array.length-1-i; j++) 
                if(array[j] > array[j+1])
                    int tmp = 0;
                    tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flg = true;
                
            
            if(flg == false)
                return;
            
        
    

• 注意：flg标志位要放在趟数循环内部，因为每次循环都要把flg = false；否则如果放在循环外部，只要执行过一次交换，flg就为true了，那么就检测不到这趟是否完成了排序。 

4、结语

• 其实，冒泡排序我们本身是不难实现的，但是你能否做到三次代码优化呢？相信看完这次blog你也可以实现。
• 接下来，博主会更新类与对象的相关内容，期待大家的持续关注！