[冒泡排序优化]

参考链接：

https://mp.weixin.qq.com/s/pK6GvkwHFnnDKo4r28G2Qw    漫画：什么是冒泡排序？

https://blog.csdn.net/MaggieDorami/article/details/7956945  【排序算法】鸡尾酒排序的实现与分析

http://www.php.cn/csharp-article-351341.html  鸡尾酒排序（双冒泡排序、搅拌排序或涟漪排序）

//====================实现代码===================================

#include <iostream>

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

void printList(int *nums, int size)
{
    printf("\n");
    for(int i=0; i<size; ++i)
    {
        printf("%d ", nums[i]);
    }
    printf("\n");
}

//基本冒泡排序 
void bubbleSort1(int nums[], int size)
{
    for(int i=0; i<size; ++i)
    {
        for(int j=0; j<size-i-1; ++j)
        {
            if(nums[j] > nums[j+1])
            {
                int temp=nums[j];
                nums[j]=nums[j+1];
                nums[j+1]=temp;
            }
        }
    }
}

//基本冒泡排序优化1 
void bubbleSort2(int nums[], int size)
{
    bool isSorted=true; //有序标记
    
    for(int i=0; i<size; ++i)
    {
        //有序标记，每一轮的初始是true
        isSorted=true;
        
        for(int j=0; j<size-i-1; ++j)
        {
            if(nums[j] > nums[j+1])
            {
                int temp=nums[j];
                nums[j]=nums[j+1];
                nums[j+1]=temp;
                
                //有元素交换，所以不是有序，标记变为false
                isSorted=false;
            }
        }
        
        //如果元素有序，则退出循环，排序结束 
        if(isSorted)
            break;
    }
}

//基本冒泡排序优化2 
void bubbleSort3(int nums[], int size)
{
    bool isSorted=true; //有序标记
    int border = size-1; //无序数列的边界，每次比较只需要比到这里为止 
    int lastChangedIndex=0; //记录最后一次交换的位置
    
    for(int i=0; i<size; ++i)
    {
        //有序标记，每一轮的初始是true
        isSorted=true;
        lastChangedIndex=0;
        
        for(int j=0; j<border; ++j)
        {
            if(nums[j] > nums[j+1])
            {
                int temp=nums[j];
                nums[j]=nums[j+1];
                nums[j+1]=temp;
                
                //记录最后一次交换元素的位置
                lastChangedIndex = j;
                
                //有元素交换，所以不是有序，标记变为false
                isSorted=false;
            }
        }
        
        //如果元素有序，则退出循环，排序结束 
        if(isSorted)
            break;
        
        //更新无序序列的边界 
        border = lastChangedIndex;
    }
}

//基本鸡尾酒排序
void bubbleSort4(int nums[], int size)
{
    int low=0, high=size-1;
    
    while(low<high)
    {
        for(int i=low; i<high; ++i)
        {
            if(nums[i] > nums[i+1])
            {
                int temp=nums[i];
                nums[i]=nums[i+1];
                nums[i+1]=temp;
            }
        }
        high--;
        
        for(int j=high; j>low; --j)
        {
            if(nums[j] < nums[j-1])
            {
                int temp=nums[j];
                nums[j]=nums[j-1];
                nums[j-1]=temp;
                
            }
        }
        low++;        
    }
}

//鸡尾酒排序优化1 
void bubbleSort5(int nums[], int size)
{
    bool isSorted=true; //有序标记    
    int low=0, high=size-1;
    
    while(low<high)
    {
        //有序标记，每一轮的初始是true
        isSorted=true;
        
        for(int i=low; i<high; ++i)
        {
            if(nums[i] > nums[i+1])
            {
                int temp=nums[i];
                nums[i]=nums[i+1];
                nums[i+1]=temp;
                
                //有元素交换，所以不是有序，标记变为false
                isSorted=false;
            }
        }
        high--;
        
        for(int j=high; j>low; --j)
        {
            if(nums[j] < nums[j-1])
            {
                int temp=nums[j];
                nums[j]=nums[j-1];
                nums[j-1]=temp;
                
                //有元素交换，所以不是有序，标记变为false
                isSorted=false;
            }
        }
        low++;
                
        //如果元素有序，则退出循环，排序结束 
        if(isSorted)
            break;        
    }
}

//鸡尾酒排序优化2 
void bubbleSort6(int nums[], int size)
{
    bool isSorted=true; //有序标记    
    int low=0, high=size-1;
    int lastChangedIndex=0; //记录最后一次交换的位置
    
    while(low<high)
    {
        //有序标记，每一轮的初始是true
        isSorted=true;
        
        for(int i=low; i<high; ++i)
        {
            if(nums[i] > nums[i+1])
            {
                int temp=nums[i];
                nums[i]=nums[i+1];
                nums[i+1]=temp;
                
                //记录最后一次交换元素的位置
                lastChangedIndex=i; 
                
                //有元素交换，所以不是有序，标记变为false
                isSorted=false;
            }
        }
        //如果元素有序，则退出循环，排序结束 
        if(isSorted)
            break;    
            
        //更新无序上边界 
        high = lastChangedIndex; 
        
            
        isSorted=true;
        for(int j=high; j>low; --j)
        {
            if(nums[j] < nums[j-1])
            {
                int temp=nums[j];
                nums[j]=nums[j-1];
                nums[j-1]=temp;
                
                //记录最后一次交换元素的位置
                lastChangedIndex=j;
                
                //有元素交换，所以不是有序，标记变为false
                isSorted=false;
            }
        }
                
        //如果元素有序，则退出循环，排序结束 
        if(isSorted)
            break;    
        
        //更新无序下边界 
        low=lastChangedIndex;    
    }
}

int main(int argc, char** argv) {
    
    int size=8;
    int list[8]={5,8,6,3,9,2,1,7}; 
    
    printf("排序前:");
    printList(list, size);
    
    //bubbleSort1(list, size);

    //bubbleSort2(list, size);

    //bubbleSort3(list, size);    
    
    //bubbleSort4(list, size);    
    
    //bubbleSort5(list, size);
    
    bubbleSort6(list, size);
    
    printf("排序后:");
    printList(list, size);
    
    return 0;
}