排序 - 冒泡排序

首先想，给你一个无序的数组，让你求其中的一个最大值？

我们可以轻松的想到，从头开始对数组两两进行比较，不断的把相对较大往后移动，比如：

3 2 1 4 7 6 5

2 3 1 4 7 6 5 // 2 和 3 比较，2，3 交换

2 1 3 4 7 6 5 // 3 和 1 比较，3，1 交换

2 1 3 4 7 6 5 // 3 和 4 比较，4比3大，4，3不交换

2 1 3 4 7 6 5 // 7 和 4比较，7比4大，7，4不交换

2 1 3 4 6 7 5 // 7 和 6 比较，6，7交换

2 1 3 4 6 5 7 // 7 和 5 比较，5，7交换

确定了最大值 7 的位置后

我们可以用同样的方法确定其 对 2 1 3 4 6 5 进行一趟，确定第二大的值6，并将6后移到倒数第二位

然后再确定第三大，第四大…直到全部数列有序

Java 实现排序如下：

public static int[] BubbleSort(int array[]){
        int size = array.length;
        int temp = 0; // 一个额外的空间复杂度
        for (int i = 0; i < size; i++) {
            for (int j = 1; j < size-i ; j++) {
                if (array[j] < array[j-1]){
                    // 把大数置换到后面
                    temp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = temp;
                }
            }
        }
        return array;
    }

算法的平均时间复杂度为 O（n*n）， 空间复杂度为 O（1）

冒泡排序的优化

冒泡排序的 最优时间复杂度 为 O(n) ，也就是在越是基本有序，越快

优化方法：添加一个 flag，标记此躺有没有进行数的置换，如果没有，那么说明此时的数组已经是有序的了

public static int[] BubbleSort(int array[]){
        int size = array.length;
        boolean flag = false;
        int temp = 0; // 一个额外的空间复杂度
        for (int i = 0; i < size; i++) {
            for (int j = 1; j < size-i ; j++) {
                flag =  false;
                if (array[j] < array[j-1]){
                    // 把大数置换到后面
                    temp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = temp;
                    flag = true;
                }
            }
            if (!flag) break;
        }
        return array;
    }