冒泡排序

冒泡排序是把相邻的两个数据进行排序，比如把下面的数据按大小排序

int[] arry = {1,4,2,5,3,9,6,7};

先把1和4进行排序，1比4小，就不动，再把4和2比，2比4小，2和4交换位置。经过一次循环之后就能把数组中最大的数据放在最后一位

public class Test {
    @org.junit.Test
    public void Test(){
        int[] arry = {1,4,2,5,3,9,6,7};
        for (int i:arry){
            System.out.print(i+"");
        }
        System.out.println();
        bubbleSort(arry);
        for (int i:arry){
            System.out.print(i+"");
        }
    }

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

输出结果：

14253967
12435679

9已经在最后一位了。
整个数组一共8个数据，我们已经排好了9，然后只需要再排序前面7个数据，就又可以产生一个排序完成的数据，以此类推，我们只需要修改上面for循环中的arry.length的大小可以把怎么数组进行排序；

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

排序结果：

14253967
12435679

这样已经还不错了，但是还存在一个问题，外层的for循环遍历了 array.length - 1次，如果在这之前数据就已经排序完成，后面的循环就是多余的了。
改进一下：

public static void bubbleSort(int[] array) {
        for (int i = array.length - 1; i > 0; i--) {
            boolean flag = true;
            for (int j = 0; j < i; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = false;
                }
            }
            if (flag) {
                //已经提前排序完成 不用把所有的都遍历一遍
                break;
            }
        }
    }

多关键字排序：
比如纸牌先按点数排序，然后按花色排序。
定义一个纸牌Card，并规定排序规则

public class Card implements Comparable{
    public int point;
    public int color;


    public Card(int color, int point) {
        this.color = color;
        this.point = point;
    }

    @Override
    public int compareTo(@NonNull Object o) {
        Card card = (Card) o;
        if (this.point>card.point){
            return 1;
        }else if (this.point<card.point){
            return -1;
        }
        if (this.color>card.color){
            return 1;
        }else if (this.color<card.color){
            return -1;
        }
        return 0;
    }

    @Override
    public String toString() {
        return "Card{" +
                "point=" + point +
                ", color=" + color +
                '}';
    }
}

初始化一个Card数组并调用排序

    @org.junit.Test
    public void Test() {
        Card[] cards = new Card[]{new Card(3,9),new Card(2,7),new Card(1,7),new Card(4,3)};
        bubbleSort(cards);
        for (Card card:cards){
            System.out.println(card.toString());
        }
    }

排序：

 public static void bubbleSort(Card[] array) {
        for (int i = array.length - 1; i > 0; i--) {
            boolean flag = true;
            for (int j = 0; j < i; j++) {
                if (array[j].compareTo(array[j + 1]) > 0) {
                    Card temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = false;
                }
            }
            if (flag) {
                //已经提前排序完成 不用把所有的都遍历一遍
                break;
            }
        }
    }

输出结果：

Card{point=3, color=4}
Card{point=7, color=1}
Card{point=7, color=2}
Card{point=9, color=3}

先按点数排序，相同的点数，按颜色排序。

2的三次方(8)个数以内的排序就用冒泡排序