优化冒泡排序及鸡尾酒排序

 

冒泡排序

• 冒泡排序的可视化图：

  • 

• 冒泡排序的概念:冒泡排序是一种交换排序，它的基本思想是：两两比较相邻记录的关键字，如果反序则交换，直至没有反序的记录为止。因为按照该算法，每次比较会将当前未排序的记录序列中最小的关键字移至未排序的记录序列最前（或者将当前未排序的记录序列中最大的关键字移至未排序的记录序列最后），就像冒泡一样，故以此为名。

• 冒泡排序算法的算法描述如下：

  • 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
  • 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
  • 针对所有的元素重复以上的步骤，除了最后一个。
  • 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
• 冒泡排序的代码实现：

private static void sort(int[] array) {
    int lastExchangeIndex = 0;
    int sortBorder = array.length -1;
    for (int i = 0; i< array.length; i++) {
        //有序标记，每一轮的初始是true
        boolean isSorted = true;
        for (int j = 0;j < sortBorder; j++) {
            if (array[j] > array[j+1]) {
                //首尾替换（装逼型）
                array[j] = array[j] ^ array[j+1];
                array[j+1] = array[j+1] ^ array[j];
                array[j] = array[j] ^ array[j+1];
                //有元素交换，所以不是有序，标记为false
                isSorted = false;
                lastExchangeIndex = j;
            }
        }
        sortBorder = lastExchangeIndex;
        if (isSorted) {
            break;
        }
    }
}

冒泡排序的复杂度：

• 时间复杂度 $O(n^{2})$
• 最优时间复杂度 $O(n)$
• 平均时间复杂度 $O(n^{2})$
• 空间复杂度：总共 $O(n)$，辅助空间： $O(1)$

 

• 鸡尾酒排序，也叫定向冒泡排序，是冒泡排序的一种改进。此算法与冒泡排序的不同之处在于从低到高排然后从高到低排，而冒泡排序则仅从低到高去比较序列中的每个元素，可以得到比冒泡排序稍微好一点的效能。
• 最差时间复杂度O(n^2)
• 最优时间复杂度-如果序列在一开始已经大部分排列过的话，会接近o(n)
• 平均复杂度-o(n^2)
• 稳定排序
• 鸡尾酒排序的可视化图：
• 
• 鸡尾酒排序的代码实现：

private static void cockTailSort(int[] array) {
        int descBorder = 0;
        int lastExchangeIndex = 0;
        int sortBorder = array.length - 1;
        //因为是双向比较，所以比较次数为原数组的1/2即可
        for (int i = 0; i < array.length / 2; i++) {
            //判断是否还有排序
            boolean isSorted = true;
            //从前到后的排序（升序）
            for (int m = descBorder; m < sortBorder; m++) {
                if (array[m] > array[m + 1]) {
                    System.out.println(array[m] + "----" + array[m + 1]);
                    //首尾替换（装逼型，无需创建新变量）
                    array[m] = array[m] ^ array[m + 1];
                    array[m + 1] = array[m + 1] ^ array[m];
                    array[m] = array[m] ^ array[m + 1];
                    System.out.println(array[m] + "----" + array[m + 1]);
                    lastExchangeIndex = m;
                }
            }
            sortBorder = lastExchangeIndex;
            //此打印方便查看元素变化
            System.out.println("升序 ------》" + Arrays.toString(array));
            //从后到到的排序（降序,升序最大数不参与降序排序）
            for (int n = sortBorder; n > descBorder; n --) {
                if (array[n] < array[n - 1]) {
                    System.out.println(array[n] + "----" + array[n - 1]);
                    array[n] = array[n] ^ array[n - 1];
                    array[n - 1] = array[n - 1] ^ array[n];
                    array[n] = array[n] ^ array[n - 1];
                    System.out.println(array[n] + "----" + array[n - 1]);
                    //有元素交换，所以不是有序，标记为false
                    isSorted = false;
                    lastExchangeIndex = n;
                }
            }
            descBorder = lastExchangeIndex;
            System.out.println("降序 ------》" + Arrays.toString(array));
            if (isSorted) {
                break;
            }
        }
}