排序算法：冒泡排序

一、原理

每次比较两个相邻的元素，如果它们的顺序错误就把它们交换过来

每一趟将一个数归位。

比如：第一趟，比较12和35的大小，若前一个比后一位大，则交换位置。12<35，无须交换。35<99，无须交换。99>18，交换位置。99>13，交换位置。比较了4次，确定最大数为99

第二趟，同理。12<35，无须交换。35>18，交换位置。35>13，交换位置。因为上一轮已经确定了99是最大的数字，因此无须再比较。本次比较了3次，确定除了99之外的最大数为35

第三趟，同理。12<18，无须交换。18>13，交换位置。因为前两轮已经确定了最大数以及第二大数，因此也无须再比较。本次比较了2次，确定了除了99和35之外的最大数为18

第四趟，同理。12<13，无需交换。比较了1次，确定了除99、35、18之外的最大数为13

至此，排序结束。5个数已经有4个数归位，最后剩一个数字，也无须再比较，直接放到第一位即可。

二、java代码

/**
 * 冒泡排序
 */
public class BubbleSort {
    public static void main(String[] args) {
//        int[] a = {10, -1, 3, 0, 9, 4, 46, 33};
        int[] a = {-1, 0, 3, 4, 9, 10, 33, 46};
        positiveSort(a);
        System.out.print("正序：");
        print(a);
        System.out.println();
        
        System.out.print("倒序：");
        reverseSort(a);
        print(a);
    }

    /**
     * 正序
     */
    public static void positiveSort(int[] a) {
        // 大循环a.length-1次
        for (int i = 0; i < a.length; i++) {
            // 小循环 a.length-1-i次
            for (int j = 0; j < a.length - i; j++) {
                // 最后一次不用比较
                if (j != a.length - 1) {
                    // 若前一个数字比后一个数字大，则交换位置
                    if (a[j] > a[j + 1]) {
                        int asd = a[j];
                        a[j] = a[j + 1];
                        a[j + 1] = asd;
                    }
                }
            }
        }
    }

    /**
     * 倒序
     *
     * @param a
     */
    public static void reverseSort(int[] a) {
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a.length - i; j++) {
                if (j != a.length - 1) {
                    if (a[j] < a[j + 1]) {
                        int asd = a[j];
                        a[j] = a[j + 1];
                        a[j + 1] = asd;
                    }
                }
            }
        }
    }

    /**
     * 打印数组
     *
     * @param a
     */
    public static void print(int[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + ",");
        }
    }
}

三、时间复杂度

O()

推导过程：由上面的推理过程不难看出，比较的次数：(n-1)+(n-2)+(n-3)+...+2+1=，时间复杂度，对于常数忽略不计，且只取最大次方，因此最后是