冒泡排序算法

冒泡排序算法的运作如下：（从后往前）

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

举个例子：对3,6,4,7,9,1进行冒泡排序

第一次冒泡
3和6是第一对相邻的元素，第二个数大，所以它俩位置不变，现在6和4又是一对相邻的元素，第一个数大，交换位置，现在变为3,4,6,7,9,1。6和7比较，不交换位置。7和9比较，不交换位置，9和1比较，交换位置，最后这组数的顺序是3,4,6,7,1,9。两两比较的结果就是第二个数永远是最大的，第一次冒泡结束后，最大的数就冒泡到了最前面。

第二次冒泡
3,4,6,7,1,9最右边的数已经是最大了，我们只需要对3,4,6,7,1进行冒泡排序就可以了。排序的结果是3,4,6,1,7

第三次冒泡
对3,4,6,1进行冒泡排序。结果是3,4,1,6

第四次冒泡
对3,4,1冒泡排序。结果是3,1,4

第五次冒泡
对3,1冒泡排序。结果是1,3

五次冒泡完成后的排列顺序就变为1,3,4,6,7,9，这样我们就实现了给这组数排序的目的。

代码实现：综上所述，要实现这个功能，需要用到for循环嵌套，外面一层应该是冒泡的次数，里面一层就是每次冒泡的交换循环。

public class Demo {
    public static void main(String[] args) {
        int[] array = { 3, 6, 4, 7, 9, 1 };
        // 进行n-1次冒泡
        for (int i = 1; i <= array.length - 1; i++) {
            // 每次冒泡比较n-i次
            for (int j = 0; j < array.length - i; j++) {
                // 第一个数比第二个数大，交换位置
                if (array[j] > array[j + 1]) {
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
            }
        }
        // 输出array数组
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
    }
}
输出结果为：1 3 4 6 7 9 

我们还可以对上述算法进行优化，如果要对2,4,6,8,7进行排序的话，第一次冒泡之后就变为2,4,6,7,8，之后的冒泡就可以省略了。因为每次冒泡交换顺序的话，都是左边的比右边的大，如果有一次冒泡没有数字交换顺序，那么右边的数字一定都比左边大，这样排序就完成了。我们可以设置一个标志，来表示一次冒泡是否交换顺序。

public class Demo {
    public static void main(String[] args) {
        int[] array = { 3, 6, 4, 7, 9, 1 };
        int n = array.length;
        boolean flag = true;
        while (flag) {
            flag = false;
            for (int j = 0; j < n - 1; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                    flag = true;
                }
            }
            n--;
        }
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
}

还有一种情况，一个数组有100个数字，前面10个无序，后面90个已经排好顺序且都小于之前的数字，那么我们只需要在第一次冒泡的时候确定最后发生交换的位置，这个位置一定小于10。从第二次冒泡开始，只需要对这个位置之前的数字进行排序即可。

public class Demo {
    public static void main(String[] args) {
        // 初始化一个数组，这次从大到小排列，前四个数字为2,3,1,4，其他默认为0
        int a[] = new int[100];
        a[0] = 2;
        a[1] = 3;
        a[2] = 1;
        a[3] = 4;
        int k;// 记录标志位置
        int flag = a.length - 1;// 第一次冒泡全部数字
        while (flag > 0) {
            k = flag;
            flag = 0;
            for (int i = 0; i < k; i++) {
                if (a[i] < a[i + 1]) {
                    int temp = a[i + 1];
                    a[i + 1] = a[i];
                    a[i] = temp;
                    flag = i;
                }
            }

        }
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]);
        }

    }
}
输出为：43210000000000000000000000000000000......