排序——冒泡排序

从小到大排序

冒泡排序：

经过两次循环，在每次小循环的时候，比较左右两个数的大小（若左大右小，则交换顺序），依次比较，得到的是最大的那一个放在n-1处，

然后小循环的范围缩小一个，依次进行比较，找出第二大的，放在n-2处，就像冒泡一样，数字按照从大到小一个一个的冒上来。

所以，外面的大循环要控制小循环比较的范围，应该倒序循环

而里面的小循环则依次比较，直到大循环控制的边界处，则将最后的值放在此处即可。

最主要的就是大循环从大到小（确定冒泡范围），小循环从小到大（寻找第i大的值）

注：看结果，到后面会有很多交换其实已经结束了，但是还要继续循环，所以，设置一个exchange来标记，

第i次循环，0 - i-1，i - n 分别为无序和有序

若没有交换的话，证明前边的已经有序，所以不用继续了。

4 2 1 6 3 6 0 -5 1 1
2 1 4 3 6 0 -5 1 1 6
1 2 3 4 0 -5 1 1 6 6
1 2 3 0 -5 1 1 4 6 6
1 2 0 -5 1 1 3 4 6 6
1 0 -5 1 1 2 3 4 6 6
0 -5 1 1 1 2 3 4 6 6
-5 0 1 1 1 2 3 4 6 6
-5 0 1 1 1 2 3 4 6 6
-5 0 1 1 1 2 3 4 6 6（多余的）

public class BubbleSort {
    public void bubbleSort(Integer[] arrays){
        if(arrays.length == 0 || arrays == null) return;
        int len = arrays.length;
        Boolean exchange;
        for(int i = len - 1; i > 0; i--){
            exchange = false;
            for(int j = 0; j < i; j++){
                if(arrays[j] > arrays[j + 1]){
                    swap( arrays, j, j + 1 );
                    exchange = true;
                }
            }
            if(!exchange) return;
        }
    }
    public void swap(Integer[] arrays, int left, int right){
        int temp = arrays[left];
        arrays[left] = arrays[right];
        arrays[right] = temp;
    }

　　

　　

测试：

import sort.BubbleSort;

import static sort.PrintRes.print;

/**
 * Created by Skye on 2018/3/27.
 */
public class SortTest {

    public static void main(String[] args){

        Integer [] arrays = {4, 7, 9, 1, 8, 5, 2, 6, 3};

        print(arrays);
        BubbleSort bubbleSort = new BubbleSort();
        bubbleSort.bubbleSort(arrays);
        print(arrays);
    }
}

　　

print方法

package sort;

/**
 * Created by Skye on 2018/3/27.
 */
public class PrintRes {

    public static void print(Integer[] arrays){
        for(int i = 0; i < arrays.length; i++){
            System.out.print(arrays[i] + " ");
        }
        System.out.println();
    }
}