鸡尾酒排序真的好吗？

#include <iostream>
#include <vector>
#include <ctime>

#define THOUSAND 1000

using namespace std;

// 常规冒泡,逐步把最大的放在尾端
void sortByBubbing1_0(vector<int> &arr)
{
    int size = arr.size();
    // 1_0的优化，加入了isChange参数
    bool isChange = false;
    for (int j = 1; j < size; j++)
    {
        for(int i = 0; i < size-j; i++)
        {
            if (arr[i]>arr[i+1])
            {
                swap(arr[i],arr[i+1]);
                isChange = true;
            }
        }
        if (!isChange) break;
    }
}

// 记录交换的位置，下一次就不用从头开始了
void sortByBubbing1_1(vector<int> &arr)
{
    int size = arr.size();
    //    int i, sum = 0;
    int p = -1;
    for (int j = 1; j < size; j++)
    {
        int first = 0;
        int iStart = (p < 2) ? 0 : p-1;
        p = -1;
        for (int i = iStart; i < size-j; i++)
        {
            if (arr[i]>arr[i+1])
            {
                if (first == 0)
                {
                    p = i;
                    ++first;
                }
                swap(arr[i],arr[i+1]);
            }
        }
        if (p < 0) break;
    }
}

// 双向冒泡排序(也称鸡尾酒冒泡)
void sortByBubbing1_2(vector<int> &arr)
{
    int size = arr.size();
    bool isChange = false;
    for (int i = 1;i < size; ++i)
    {
        if (i & 1 == 1)
        {
            for (int j = i/2; j < size - i/2 - 1; ++j)
            {
                if (arr[j] > arr[j+1])
                {
                    swap(arr[j],arr[j+1]);
                    isChange = true;
                }
            }
        } else {
            for (int j = size - i/2 - 1; j > 0; --j)
            {
                if (arr[j] < arr[j-1])
                {
                    swap(arr[j],arr[j-1]);
                    isChange = true;
                }
            }
        }
        if (!isChange) break;
    }
}

// 双向冒泡排序优化，用了1_2的方法进行优化
void sortByBubbing1_3(vector<int> &arr)
{
    int size = arr.size();
    int p = -1;
    for (int i = 1;i < size; ++i)
    {
        if (i & 1 == 1)
        {
            // 因为p-2至少得大于初始值才有意义
            int jStart = (p < 2 + i/2) ? i/2 : p - 2;
            p = -1;
            for (int j = jStart; j < size - i/2 -1; ++j)
            {
                if (arr[j] > arr[j+1])
                {
                    swap(arr[j],arr[j+1]);
                    p = j;
                }
            }
        } else {
            // 因为p+2至少得小于初始值才有意义
            int jStart = (p < size - i/2 + 1) ? size - i/2 -1 : p + 2;
            p = -1;
            for (int j = jStart; j > 0; --j)
            {
                if (arr[j] < arr[j-1])
                {
                    swap(arr[j],arr[j-1]);
                    p = j;
                }
            }
        }
        if (p < 0) break;
    }
}

int main()
{
    srand((unsigned)time(NULL));
    vector<int> arr = {1,2,3,4,5,6,7,8,9,0,10,11,12,13,14,15,16,17,18,22,33,44,55,66,77,88,99,100,89};
    clock_t start = clock();
    for (int q=0;q<THOUSAND*THOUSAND*2;++q)
    {
        // 这个就是我们之前学到的洗牌算法了
        for (int i=arr.size()-1; i > 0 ;--i)
        {
            swap(arr[i],arr[rand()%(i+1)]);
        }
        // 这里选择执行的函数
        sortByBubbing1_0(arr);
    }
    
    clock_t end = clock();
    double endtime=(double)(end-start)/CLOCKS_PER_SEC;
    cout<<"Total time:"<<endtime*1000<<"ms"<<endl;  //ms为单位
    
    // 查看排序的正确性
        for (int i = 0; i < arr.size(); ++i)
        {
            cout << "a[" <<i<<"]="<< arr[i] << endl;
        }
    return 0;
}

每个函数执行若干遍后发现，鸡尾酒排序对比普通冒泡来说，不但代码多，而且执行效率也是一样的，可见其在随机输入的情况下是没有优势的。

 

对比两种算法，冒泡将最大值不断向右侧堆叠。而鸡尾酒将依次将最大和最小往两边堆叠，所谓鸡尾酒的优点在2,3,4,5,6,1少执行几次遍历，但如5,6,1,2,3,4或4,5,6,1,2,3，鸡尾酒排序又得多排几次。

 

既然宏观上两者效率差不多，而且两者本质一样，那么一方面的优点一定会被另一方面的缺点，也不存在鸡尾酒是冒泡的升级版的说法，希望学习时能有独立思想不要人云亦云。

 

 

 

点击关注，持续推送质量好文；如有不当，欢迎指出；转载请注明出处。