理论基础 —— 排序 —— 鸡尾酒排序

【概述】

鸡尾酒排序也称定向冒泡排序，是一种稳定的排序方法，其是原始冒泡排序的改进，也是交换排序的一种。

定向冒泡排序与冒泡排序的不同在于其从低到高比较，然后再从高到低比较，如此循环往复，直到序列有序，而冒泡排序仅是从低到高的去比较序列中的每个元素。

其实现借助两个指针来完成，一个作为头指针，负责从前向后扫描，一个作为尾指针，负责从后向前扫描，外层循环依靠指针控制数组左右边界，内层循环分别控制前后边界的排序。

【过程】

初始关键字：  『 6，5，3，1，8，7，2，4  』

第一趟排序：  『 6，5，3，1，8，7，2，4  』

                        5，『 6，3，1，8，7，2，4』

                        5，3，『 6，1，8，7，2，4』

                        5，3，1，『 6，8，7，2，4』

                        5，3，1，6，『 8，7，2，4』

                        5，3，1，6，7，『 8，2，4』

                        5，3，1，6，7，2，『 8，4』

                        5，3，1，6，7，2，4，『 8』

第二趟排序：『 5，3，1，6，7，2，4』，8

                      『 5，3，1，6，7，2』，4，8

                      『 5，3，1，6，2』，7，4，8

                      『 5，3，1，2』，6，7，4，8

                      『 5，3，1』，2，6，7，4，8

                      『 5，1』，2，3，6，7，4，8

                      『 1』，2，5，3，6，7，4，8

第三趟排序： 1，『2，5，3，6，7，4』，8

                       1，2，『5，3，6，7，4』，8

                       1，2，3，『5，6，7，4』，8

                       1，2，3，5，『6，7，4』，8

                       1，2，3，5，6，『7，4』，8

                       1，2，3，5，6，4，『7』，8

第四趟排序： 1，『2，3，5，6，4』，7，8

                       1，『2，3，5，4』，6，7，8

                       1，『2，3，4』，5，6，7，8

                       1，『2，3』，4，5，6，7，8

                       1，『2』，3，4，5，6，7，8

第五趟排序： 1，2，『3，4，5，6』，7，8

                       1，2，3，『4，5，6』，7，8

                       1，2，3，4，『5，6』，7，8

                       1，2，3，4，5，『6』，7，8

第六趟排序： 1，2，『3，4，5』，6，7，8

                       1，2，『3，4』，5，6，7，8

                       1，2，『3』，4，5，6，7，8

第七趟排序：  1，2，3，『4，5』，6，7，8

结果：   『  1，2，3，4，5，6，7，8  』

     

                       宏观过程

【时空复杂度分析】

最好的情况，是要排序的表本身就是有序的，只需要进行 n-1 次比较，没有数据交换，因此最优时间复杂度为 O(n)

最坏的情况，是要排序的表是逆序的情况，因此供需比较 n(n-1)/2 次，并作等数量级的记录移动，因此最坏时间复杂度为 O(n^2)

而在平均情况下，时间复杂度与最坏时间复杂度同数量级，即平均时间复杂度为 O(n^2)

此外，定向冒泡排序仅需一个辅助空间，用于作记录交换的暂存单元，即空间复杂度为 O(1)

【源程序】

void cocktailSort(int a[],int n){
    int left=1,right=n;
    while(left<right){
        /*前半轮,将最大元素放到后面*/
        for(int i=left;i<right;i++)
            if(a[i]>a[i+1])
                swap(a[i],a[i+1]);
        right--;
        /*后半轮,将最小元素放到前面*/
        for(int i=right;i>left;i--)
            if(a[i-1]>a[i])
                swap(a[i],a[i-1]);
        left++;

    }
}