java基础算法系列（二）冒泡排序的优化讲解（鸡尾酒算法）

上一篇文章我们讲解了冒泡排序的简单优化，但是这个优化我们还是能发现问题，那就是我们只注意了到了从前往后进行冒泡排序，而从后往前排序也是可以的，那么我们可以来了解一下鸡尾酒排序。

鸡尾酒排序：

其每一趟排序都可以将当前的最大值和最小值放置到正确的位置.传统的鸡尾酒排序 算法即使引入了标志是否交换的变量来记录前一趟数据是否发生交换从而确定排序是否结束,也无法处理前一趟排序有数据交换但是某些连续的数据存储子区间无交 换的情况.为了有效降低不必要的比较,引入了一种鸡尾酒排序算法的改进算法.

public static void main(String[] args) {

        int[] arr = { 1, 3, 4, 2, 6, 7, 8, 0, 5 };
        // 将最小值排到队尾
        long startTime = System.nanoTime(); // 获取开始时间
        for (int i = 0; i < arr.length / 2; i++) {
            for (int j = i; 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;
                }
            }
            // 将最大值排到队头
            for (int j = arr.length - 1 - (i + 1); j > i; j--) {
                if (arr[j] < arr[j - 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                }
            }
        }
        long endTime = System.nanoTime(); // 获取结束时间
        System.out.println("排序結果:" + Arrays.toString(arr));
        System.out.println("程序运行时间： " + (endTime - startTime) + "ns");
    }

打印结果

排序結果:[0, 1, 2, 3, 4, 5, 6, 7, 8]
程序运行时间：3600ns

那么我们上述鸡尾酒算法是否也能优化一下呢？我们来可以试试在左右起始位置定义一个索引，然后定义循环的方向，在每一个大循环中依次进行小循环，由于while循环比较好写，这里用了while循环。

public static void main(String[] args) {
        int[] arr = { 1, 2, 4, 3, 6, 7, 8, 0, 5, 9 };
        int left = 0; // 左向循环起始位置
        int right = arr.length - 1; // 右向循环起始位置
        boolean leftToRight = true; // 循环方向
        long startTime = System.nanoTime(); // 获取开始时间
        while (left < right) {
            if (leftToRight) {
                // 从左到右，依次比较大小，排序完得到该趟排序右边最大值
                for (int i = left; i < right; i++) {
                    if (arr[i] > arr[i + 1]) {
                        arr[i] = arr[i] ^ arr[i + 1];
                        arr[i + 1] = arr[i] ^ arr[i + 1];
                        arr[i] = arr[i] ^ arr[i + 1];
                    }
                }
                right--;
                leftToRight = false;
            } else {
                // 从右到左，依次比较大小，排序完得到该趟排序左边最小值
                for (int j = right; j > left; j--) {
                    if (arr[j - 1] > arr[j]) {
                        arr[j - 1] = arr[j - 1] ^ arr[j];
                        arr[j] = arr[j - 1] ^ arr[j];
                        arr[j - 1] = arr[j - 1] ^ arr[j];
                    }
                }
                left++;
                leftToRight = true;
            }
        }
        long endTime = System.nanoTime(); // 获取结束时间
        System.out.println("排序結果:" + Arrays.toString(arr));
        System.out.println("程序运行时间： " + (endTime - startTime) + "ns");

    }

打印结果如下：

排序結果:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
程序运行时间：2300ns

有人会说，上面的代码优化了吗，第一个鸡尾酒算法经过计算一共进入了12次循环，第二个则进入了11次，根据数据的不同而异。效率有些许的提升。

本章节是来自整理的java基础算法的第二节。你看完本系列文章，是不是感觉面试offer又能多2K！！

                         点关注！不迷路~~各种福利、资源定期分享！！