排序-冒泡排序

冒泡排序，类似于水中冒泡，往上浮的泡泡会越来越大。每一趟遍历，会将一个最大的数移到序列末尾。

算法步骤

• 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
• 针对所有的元素重复以上的步骤，除了最后一个；
• 重复步骤1~3，直到排序完成。

动图演示

代码实现

一般写法

private static void sort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

优化一

假设我们现在排序ar[]={1,2,3,4,5,6,7,8,10,9}这组数据，按照上面的排序方式，第一趟排序后将10和9交换已经有序，接下来的8趟排序就是多余的，什么也没做。所以我们可以在交换的地方加一个标记，如果那一趟排序没有交换元素，说明这组数据已经有序，不用再继续下去。

private static void sort1(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        boolean swagFlag  = false;
        for (int j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swagFlag = true;
            }
        }
        if (!swagFlag) {
            return;
        }
    }
}

优化二

优化一仅仅适用于连片有序而整体无序的数据(例如：{1,2,3,4,7,6,5})。但是对于前面大部分是无序而后边小半部分有序的数据{1,2,5,7,4,3,6,8,9,10}排序效率也不可观，对于种类型数据，我们可以继续优化。既我们可以记下最后一次交换的位置，后边没有交换，必然是有序的，然后下一次排序从第一个比较到上次记录的位置结束即可。

private static void sort2(int[] arr) {
    int left = arr.length - 1;
    for (int i = 0; i < arr.length - 1; i++) {
        boolean swagFlag = false;
        int pos = 0;
        for (int j = 0; j < left; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swagFlag = true;
                pos = j;
            }
        }
        if (!swagFlag) {
            return;
        }
        left = pos;
    }
}

left=0时，也可以代表一次交换也没发生，因此可以用left>0的片段来代替swagFlag的作用

private static void sort3(int[] arr) {
    int left = arr.length - 1;
    for (int i = 0; i < arr.length - 1 && left > 0; i++) {
        int pos = 0;
        for (int j = 0; j < left; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                pos = j;
            }
        }
        left = pos;
    }
}

优化三

优化二的效率有很大的提升，还有一种优化方法可以继续提高效率。大致思想就是一次排序可以确定两个值，正向扫描找到最大值交换到最后，反向扫描找到最小值交换到最前面。例如：排序数据{1,2,3,4,5,6,0}

private static void sort4(int[] arr) {
    int right = arr.length - 1;
    int left = 0;
    while (left < right) {
        boolean swagFlag = false;
        int pos = 0;
        for (int j = 0; j < right; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swagFlag = true;
                pos = j;
            }
        }
        System.out.println(Arrays.toString(arr));
        right = pos;
        if (!swagFlag) {
            return;
        }
        swagFlag = false;
        int pos1 = 0;
        for (int k = right; k > left; k--) {
            if (arr[k] < arr[k - 1]) {
                int tmp = arr[k];
                arr[k] = arr[k - 1];
                arr[k - 1] = tmp;
                swagFlag = true;
                pos1 = k;
            }
        }
        left = pos1;
        System.out.println(Arrays.toString(arr));
        if (!swagFlag) {
            return;
        }
    }
}