两种冒泡排序的比较及冒泡算法优化

第一种：

void bubbleSort(int array[],int len){
    //循环的次数为数组长度减一，剩下的一个数不需要排序
    for(int i=0;i<len-1;++i){
        bool noswap=true;
        //循环次数为待排序数第一位数冒泡至最高位的比较次数
        for(int j=0;j<len-i-1;++j){
            if(array[j]>array[j+1]){
                array[j]=array[j]+array[j+1];
                array[j+1]=array[j]-array[j+1];
                array[j]=array[j]-array[j+1];
                //交换或者使用如下方式
                //a=a^b;
                //b=b^a;
                //a=a^b;
                /*
                int temp;
                array[j] = temp;
                temp = array[j+1];
                array[j+1] = array[j];
                */
                noswap=false;
            }
        }
        if(noswap) break;
    }
}

第二种：

void bubbleSort(int array[],int len){

    for(int i=1;i<len-1;++i){
        bool noswap=true;

        for(int j=i+1;j<len-1;++j){
            if(array[i]>array[j]){
                array[i]=array[i]+array[j];
                array[j]=array[i]-array[j];
                array[i]=array[i]-array[j];
                //交换或者使用如下方式
                //a=a^b;
                //b=b^a;
                //a=a^b;
                noswap=false;
            }
        }
        if(noswap) break;
    }
}

没有优化

void BubbleSort1(int arr[],int len)  
{  
    int i = 0;  
    int j = 0;  

    for(i = 0; i < len - 1; i++)  
    {  
        for(j = 0; j < len - i - 1; j++)  
        {  
            int tmp  = 0;  
            if(arr[j] > arr[j+1])  
            {  
                tmp = arr[j];  
                arr[j] = arr[j+1];  
                arr[j+1] = tmp;  
            }  
        }  
    }  
}//没有优化的方法，比较常规；  

一级优化：

void BubbleSort2(int arr[],int len)  
{  
    int i = 0;  
    int j = 0;  

    for(i = 0; i < len - 1; i++)  
    {  
        int flag = 1;//假定每次进入都是有序的 flag为1；  
        for(j = 0; j < len - i - 1; j++)  
        {  
            int tmp  = 0;  
            if(arr[j] > arr[j+1])  
            {  
                tmp = arr[j];  
                arr[j] = arr[j+1];  
                arr[j+1] = tmp;  
                flag = 0;//如果发生交换，则flag 置为0；  
            }  
        }  
        if(flag == 1)//如果这趟走完，没有发生交换，则原数组有序；  
            break;  
    }  
}//加入标志位优化； 

二级优化

void BubbleSort3(int arr[],int len)  
{  
    int i = 0;  
    int j = 0;  
    int k = len - 1;//控制内部比较循环  
    int n = 0;  

    for(i = 0; i < len -1 ; i++)  
    {  
        int flag  = 1;  
        n = 0;  
        //假定每次进入都是有序的 flag为1；  
        for(j = 0; j < k; j++)  
        {     
            int tmp  = 0;  
            if(arr[j] > arr[j+1])  
            {  
                tmp = arr[j];  
                arr[j] = arr[j+1];  
                arr[j+1] = tmp;  
                flag = 0;//如果发生交换，则flag 置为0；  
                n = j;//保存最后一次交换的下标；  
            }  
        }  

        if(flag == 1)//如果这趟走完，没有发生交换，则原数组有序；  
            break;  
        k = n;//最后一次交换的位置给k，减少比较的次数；  
    }  
}//最终优化