初识冒泡排序

将{6，5,4，3,2，1}从小到排序
冒泡排序原理：
1.相邻两个元素做比较，如果前一个元素比后一个元素大，则交换两个元素的位置
2.每对相邻的的两个元素做同样的工作，从开始的第一个元素到结尾的最后一个元素，最终最后一个位置的元素就是最大的
3.在原数据的基础上，第一次冒泡最大的到最后一位，
在第一次冒泡的基础上，也就是6可以不参加运算，第二次冒泡第二大的到倒数第二位
在第二次冒泡的基础上，也就是5,6可以不参加运算，第三次冒泡第三大的到倒数第三位
在第三次冒泡的基础上，也就是4，5,6可以不参加运算，第四次冒泡第四大的到倒数第四位。。。。。。依次类推

Api设计

Bubble中包含2个方法，默认正序sort(Comparable[] arr)和自定义顺序sort(T[] arr,Comparator comparator)

public class Bubble {

    public static void main(String[] args) {
        Integer arr[] = {5,6,  4, 3, 2, 1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
        sort(arr,Comparator.reverseOrder());
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 自定义排序
     * @param arr
     * @param comparator
     * @param <T>
     */
    public static <T> void sort(T[] arr,Comparator<T> comparator) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (greater(comparator,arr[j],arr[j+1])) {
                    exch(arr, j, j + 1);
                }
            }
        }
    }




    /**
     * 正序
     * @param arr
     * @param <T>
     */
    public static <T> void sort(Comparable<T>[] arr) {
        //有多少个元素参与冒泡 i开始角标 arr.length - 1长度比最大角标小1，没有等于是因为最后一个元素后面没有相邻元素了，最后一个元素在比较元素大小的时候的j+1角标体现
        for (int i = 0; i < arr.length - 1; i++) {
            //每次循环都减少一个元素
            for (int j = 0; j < arr.length - 1 - i; j++) {
            //相邻连个元素比较
                if (greater(arr[j], arr[j + 1])) {
                    exch(arr, j, j + 1);
                }
            }
        }
    }

    /**
     * 比较大小，如果c1比c2大，返回true,否则false，正序
     *
     * @param c1
     * @param c2
     * @return
     */
    private static boolean greater(Comparable c1, Comparable c2) {
        return c1.compareTo(c2) > 0 ? Boolean.TRUE : Boolean.FALSE;
    }

    private static <T> boolean greater(Comparator comparator,T c1, T c2) {
        return comparator.compare(c1,c2) > 0 ? Boolean.TRUE : Boolean.FALSE;
    }

    /**
     * 将arr数组中i角标和j角标位置互换
     *
     * @param arr 数组
     * @param i   角标
     * @param j   角标
     * @param <T>
     */
    private static <T> void exch(T[] arr, int i, int j) {
        T temp;
        temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;

    }

}

时间复杂度分析
冒泡排序使用了双层for,其中内存循环的循环体是真正完成排序的代码，所以我们分析冒泡排序的时间复杂度，主要分析一下内层循环的执行次数即可

在最坏的情况下，也就是相邻连个元素每次都需要交换

元素的比较次数为
（n-1）+(n-2)+(n-3)+…+3+2+1=n^2/2-n/2

公式推导
设pn=(n-1）+(n-2)+(n-3)+…+3+2+1
设sn=1+2+3+…+(n-3）+(n-2)+(n-1)
pn+sn=(n-1+1)+(n-2+2)+(n-3+3)+…+(3+n-3)+(2+n-2)+(1+n-1)
因为一共有n-1个数，所以
pn+sn=n(n-1)
因为pn=sn，所以
pn=(n(n-1))/2

元素的交换次数为
（n-1）+(n-2)+(n-3)+…+3+2+1=n^2/2-n/2

总执行次数为

2(n^2/2-n/2)=n^2-n

根据大O推导法则，去掉最高项的常数因子，去掉常数项，所以时间复杂度为O(n^2)