冒泡排序的优化算法

今天我们来介绍冒泡排序的优化算法，对于冒泡排序，相信大家都不会陌生，就是说从最后一个开始挑选，越小的越往上面冒，一般来说这个算法的时间复杂度为O(n^2),但是我们原来不知道想过没有，如果这个序列本身就是很工整的按照一个从小到大的序列进行排序，如果我们依然按照冒泡排序，会显得有点愚钝，例如这个序列为3,2,1,5,9,10，这个序列中，我们只需要把3和1进行替换即可，可是如果使用冒泡的话，我们的替换就会有问题，则此时我们就可以加入一个标志，当如果这个冒泡的从后到前的一次排序时，如果没有经过替换的时候，就说明这个排序已经排序成功，则此时我们就不需要进行排序了

冒泡排序一般排法:

package BubbleArray;

public class BubbleArray1 {

    public static void main(String[] args) {
        int[] array = new int[]{1,34,16,8,96,17};
        bubbleSort(array);
        display(array);
    }

    private static void display(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

    public static void bubbleSort(int[] array) {
        for (int i = 0; i < array.length -1; i++) {
            for (int j = array.length - 1; j > i; j--) {
                if(array[j] < array[j - 1]){
                    int tmp = array[j];
                    array[j] = array[j - 1];
                    array[j - 1] = tmp;
                }
            }
        }
    }
    
}

优化后的代码，添加flag的标志

package cn.xx.test;

//冒泡
public class C {

    public static void main(String[] args) {
        int[] num = {5,47,21,56,32,3,1,4,1,2,5,3,33,5};
        sort(num);
        display(num);
    }
    public static void sort(int[] num){
        int tmp;
        boolean flag = true;
        for (int i = 0; i < num.length - 1 && flag; i++) {
            flag = false;
            for (int j = num.length - 1; j > i ; j--) {
                if(num[j] < num[j - 1]){
                    tmp = num[j];
                    num[j] = num[j - 1];
                    num[j - 1] = tmp;
                    flag = true;
                }
            }
        }
    }
    public static void display(int[] num){
        for (int i = 0; i < num.length; i++) {
            System.out.println(num[i]);
        }
    }
}