Java代码实现—冒泡排序

Posted 竹北1998

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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你也可以实现。
  • 接下来,博主会更新类与对象的相关内容,期待大家的持续关注!

Java实现冒泡排序详细代码

冒泡排序定义

冒泡排序(Bubble Sort)也是一种简单直观的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

算法步骤

比较相邻的元素。如果第一个比第二个大,就交换他们两个。

对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。

针对所有的元素重复以上的步骤,除了最后一个。

持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

具体Java代码实现

/**
 *
 *@author g0rez
 *@data 2021-05-16
 *
 */
public class 冒泡排序 {
    public static void main(String[] args) {
        int[] arr =new int[]{2,4,3,5,6,1,7,8,10,9};
        arr=bubbleSort(arr);
        for(int i = 0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
    public static int[] bubbleSort(int[] arr){
        if(arr.length==0) return arr;
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr.length-i-1;j++){
                if(arr[j]>arr[j+1]){
                    int t=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=t;
                }
            }
        }
        return arr;
    }
}

 

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

冒泡排序java

Java排序算法之冒泡排序

常见14种经典排序算法(Java代码实现)

常见排序&查询算法Java代码实现

基础算法-冒泡排序与二分查找(JAVA实现)

Java实现冒泡排序详细代码