冒泡排序优化

冒泡排序过程和实现

冒泡排序过程

设对数组a[n]按升序进行排序，外层循环遍历数组，内层循环从后往前遍历相邻的两个元素，若逆序则交换两个元素的位置。直到全部有序。

冒泡排序实现

void bubble_sort(int *array, const int size)
{  
    for (int i = 0; i < size; i++)  
    {  
        for (int j = size - 1; j > i; j--)  
        {  
            if (array[j] < array[j - 1])  
            {  
                int tmp = array[j];  
                array[j] = array[j - 1];  
                array[j - 1] = tmp;   
            }  
        }  
    }   
}  

冒泡排序优化

第一步优化

如果在某次内层循环中没有执行交换，则说明此时数组已经全部有序，无需再继续循环了。
因此可做一个标记初始化为false，每当发生交换时置标记为true。当某次内层循环没有发生交换（即标记为false时），说明已经全部有序。

void bubble_sort(int *array, const int size)
{  
    bool signal = false;  
    for (int i = 0; i < size; i++)  
    {  
        signal = false;
        for (int j = size - 1; j > i; j--)  
        { 
            if (array[j] < array[j - 1])  
            {  
                int tmp = array[j];  
                array[j] = array[j - 1];  
                array[j - 1] = tmp;  

                signal = true;  
            }  
        }  

        if(!signal)  
        {  
            break;  
        }  
    }  
}  

第二步优化

在第一步优化的基础上继续思考：设某次内层循环区间a[i...n]后a[0...i]已有序，记最后一次执行交换的位置为lastSwapPos。
不难发现a[i...lastSwapPos]也已有序，即下次循环只需要循环区间a[lastSwapPos + 1...n]即可。

void bubble_sort(int *array, const int size)
{  
    int last_swap = 0;  
    int last_swap_tmp = 0;  
    for (int i = 0; i < size; i++)  
    {  
        last_swap = last_swap_tmp;  
        for (int j = size - 1; j > last_swap; j--)  
        {  
            if (array[j] < array[j - 1])  
            {  
                int tmp = array[j];  
                array[j] = array[j - 1];  
                array[j - 1] = tmp;  

                last_swap_tmp = j;  
            }  
        }  

        if (last_swap_tmp == last_swap)  
        {  
            break;  
        }  
    } 
}  

---