整理排序算法（一）：冒泡排序

    /**
     * 冒泡排序：
     * 比较相邻两个值，如果第一个比第二个大，就交换位置。
     * 全部比较一次，一直到剩下最后一个
     * 这样每次都会把剩下最大的一个值找出来，放在最后一个位置上
     *
     *
     * 最好的时间复杂度
     * 若数组的顺序是正序的，一趟扫描即可完成排序。所需的关键字比较次数C和记录移动的次数M都是最小的值，如：arrays{1,2,3,4,5,6}
     * 和记录移动次数
     * Compare-min=n-1
     *
     * ​Move-min=0
     * 故：最好的时间复杂度O(n)
     *
     * 最坏的时间复杂度分析
     * 若数组的顺序是反序的，需要进行n-1趟排序，每趟需要n-1次的比较（1<=i<n-1），每次需要移动记录三次来交互位置，所以，比较和移动次数均达到最大值：
     * Compare-max=n(n-1)/2=O(n2)
     *
     * Move-max=3n(n-1)/2=O(n2)
     *
     * 故：冒泡排序的最坏时间复杂度为：O(n2)
     *
     * 平均时间复杂度分析
     * 所以：冒泡排序总的平均时间复杂度为：O(n2)
     * @param arr
     */
    public static void maopaoSort(int[] arr) {
//        是不是有序数列
        boolean sorted = true;
        //        循环这样比较，一直到排序完
        for (int j = 0; j < arr.length; j++) {
            //        每次比较相邻的值，第一个比第二个大，就交换位置
            for (int i = 0; i < arr.length - j - 1; i++) {
                if (arr[i] > arr[i + 1]) {
                    int tmp = arr[i + 1];
                    arr[i + 1] = arr[i];
                    arr[i] = tmp;
                    sorted = false;
                }
            }
//            说明是有序数列，不再循环
            if (sorted) {
                break;
            }
        }
    }

排序方法	平均情况	最好情况	最坏情况	辅助空间	稳定性
冒泡排序	N2	n	N2	1	稳定
选择排序	N2	N2	N2	1	不稳定
插入排序	N2	n	N2	1	稳定
希尔排序	N*logn~n2	N1.3	N2	1	不稳定
堆排序	N*logn	N*logn	N2	1	不稳定
归并排序	N*logn	N*logn	N*logn	N	稳定
快速排序	N*logn	N*logn	N2	1	不稳定