冒泡排序的原理

冒泡排序的原理很简单，我们想象一下一个一个的气泡上浮的过程。

假设我们有八个数字 29,10,14,37,20,25,44,15 要进行排序。

我们先用一个动画图来直观的观察一下整个冒泡排序的过程：

排序共进行八轮，每一轮都会做两两比较，并将较大的元素右移，就像冒泡一下。

一轮结束之后，八个元素中最大的那个元素44将会移动到最右边。

然后再重复其他的几轮。最终得到一个完全排序的数组。

也可以这样看：

第一轮是将八个元素中的最大值44交换移动到最右位置。第二轮是将八个元素中的次大值37交换移动到最右位置。以此类推。

package com.oracle.project.util;

import java.util.Arrays;

/*
创建一个数组冒泡排序的工具类
 */
public  class BubbleSort {
    //bSort1（）这个方法的性能比bSort（）低，运算次数更多
    public static void bSort1(int[] noi){
        int count=0;//计数器
        //外层循环,遍历所有轮数
        for (int i = 0; i <noi.length ; i++) {
            for (int j = 0; j < noi.length; j++) {
                count++;
                if (j+1<noi.length){
                    if (noi[j]>noi[j+1]){
                        int temp=noi[j+1];
                        noi[j+1]=noi[j];
                        noi[j]=temp;
                    }
                }
            }
        }
        System.out.println("自定义比较结果：" + Arrays.toString(noi));
        System.out.println("这是运算的次数："+count);
    }
    //(第一次修改)
    //bSort这个方法的性能更加高（运算次数比较少）第一次排序之后，44已经放到最右边的位置了，已经排好序了。
    //第二次排序之后，37也已经排好序了。每过一轮，内部循环需要比较的次数就可以减一。
    //这就意味着，在内部循环的时候，我们只需要进行array.length-i-1次比较就可以了。
    public static void bSort2(int[] noi){
        int count=0;//计数器
        //外层循环,遍历所有轮数
        for (int i = 0; i < noi.length; i++) {
            //内层循环，两两比较，选中较大的数字，进行交换, 最后的i个数字已经排完序了，不需要再进行比较
            for (int j = 0; j <noi.length-i-1 ; j++) {
                count++;
                if (noi[j]>noi[j+1]){
                    int temp=noi[j+1];
                    noi[j+1]=noi[j];
                    noi[j]=temp;
                }

            }
            System.out.println("第"+(i+1)+"轮排序"+Arrays.toString(noi));
        }
        System.out.println("自定义比较结果：" + Arrays.toString(noi));
        System.out.println("这是运算的次数："+count);

    }
    //(第二次修改)
    //从上面的结果，我们可以看到实际上第5轮排序过后就已经排序完成了。但是我们仍然进行了第6，7次排序。
    //有没有什么办法可以判断排序是不是已经完成了呢？
    //我们考虑一下，在内部循环中，我们是进行两两比较，然后交换位置。
    //如果在某一次遍历中，没有进行交互，这就意味着排序已经完成了。
    //所以我们可以再引入一个flag来做判断。
    public static void bSort3(int[] noi){
        int count=0;//计数器
        //外层循环，遍历所有轮数
        for (int i = 0; i <noi.length ; i++) {
            //添加一个flag，如果这一轮都没有排序，证明排序已经完成，可以提前退出
            boolean flag=false;

            //内层循环，两两比较，选中较大的数字，进行交换, 最后的i个数字已经排完序了，不需要再进行比较
            for (int j = 0; j <noi.length-i-1 ; j++) {
                //交换
                count++;
                if (noi[j]>noi[j+1]){
                    int temp=noi[j+1];
                    noi[j+1]=noi[j];
                    noi[j]=temp;
                    flag=true;
                }
            }
            //如果flag不是true，结束循环
            if (!flag){
                break;
            }
        }
        System.out.println("自定义比较结果：" + Arrays.toString(noi));
        System.out.println("这是运算的次数："+count);
    }
//    public void b3(int... a,String... c){
//
//    }
}

public static void main(String[] args) {
//        Random random = new Random();
//        int[] ran=new int[20];
//        for (int i = 0; i < ran.length; i++) {
//            ran[i]= random.nextInt(100);
//        }
//        BubbleSort.bSort(ran);
//        BubbleSort.bSort1(ran);
        BubbleSort.bSort1(new int[]{29,10,14,37,20,25,44,15 });
        BubbleSort.bSort2(new int[]{29,10,14,37,20,25,44,15 });
        BubbleSort.bSort3(new int[]{29,10,14,37,20,25,44,15 });

      
    }
}

运行结果：