排序：冒泡排序

算法实现

比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。
对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值。

算法实现：

/**
 * 冒泡排序
 * @author wen.jie
 * @date 2021/8/4 17:10
 */
public class Bubble {

    /**
     * 排序
     * @author wen.jie
     * @date 2021/8/4 17:28
     */
    public static void sort(Comparable<?>[] a) {
        for (int i = a.length-1; i>0; i--) {
            for (int j = 0; j < i; j++) {
                if (greater(a[j], a[j+1])){
                    exchange(a, j, j+1);
                }
            }
        }
    }

    /**
     * 比较
     * @author wen.jie
     * @date 2021/8/4 17:18
     */
    private static boolean greater(Comparable v, Comparable w) {
        return v.compareTo(w) > 0;
    }

    /**
     * 交换
     * @author wen.jie
     * @date 2021/8/4 17:27
     */
    private static void exchange(Comparable[] a, int i, int j) {
        Comparable temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

}

测试：

/**
 * @author wen.jie
 * @date 2021/8/4 17:12
 */
public class BubbleTest {

    @Test
    public void test1(){
        Integer[] arr = {5,4,2,3,6,1};
        Bubble.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

时间复杂度分析

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

在最坏情况下，也就是假如要排序的元素为{6,5,4,3,2,1}逆序，那么：

元素比较的次数为：(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;

元素交换的次数为：(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2；（最坏情况下，每一次比较都会交换）

总执行次数为：(N^2/2-N/2)+(N^2/2-N/2)=N^2-N

按照大O推导法则，保留函数中的最高阶项那么最终冒泡排序的时间复杂度为O(N^2).