冒泡排序优化

冒泡排序比较简单**，首先简单说下算法思路：

过程：

a. 从第一个记录开始和第二个记录比较，如果大于第二个记录就交换，否则就不交换，比较下一个元素，依次循环下去，因此第一趟就会找到最大的值放到数组的最后面n-1的位置上。
b. 然后用相同的方式在前n-2个元素中得出最大值放在n-2位置。
c. 重复上述操作，知道全部比较完成。

void BullSort(int a[], int length)
{
    for (size_t i = 0; i < length - 1; i++)
    {
        for (size_t j = 0; j < length-1-i; j++)
        {
            if (a[j] > a[j + 1])
            {
                swap(a[j], a[j + 1]);
            }
        }
    }
}

性能分析： T(n) = O( n ^2),k空间复杂度 S(n) = O（1）

上述对于冒泡排序没有做任何优化，所以如果是基本有序的时候效率和乱序的时候是一样的，没有什么改观，此时就需要进一步的优化，要用一个标记，当有序的时候就不需要进行比较了，代码优化如下：

void BullSort(int a[],it len)
{
    int temp;

    for(int i= 0; i<len-1; i++)
    {
        bool swap = false;

        for(int j = 0; j < len-i-1; j++)
        {
            if( a[j] > a[j+1] )
            {
                temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
                swap = true;
            }
        }
        if( false == swap)
        {
            break;
        }
    }
} 

但是可能你感觉这样就好了，但是反过来再想想，如果要是一个数列 【42,32,45,24,45,32,11】进行排序，每一趟排序是不是都要把11向前挪动只有一次，那有没有什么方法使得效率再高一点呢，有的，那就是双向冒泡，这样就可以使得11向前每次挪动两次。优化代码如下：

int BubbSort(int a[],int len)
{
    int temp;
    for(int i= 0; i<len-1; i++)
    {
        bool swap = false;

        for(int j = i; j < len-i-1; j++)
        {
            if( a[j] > a[j+1] )
            {
                temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
                swap = true;
            }
        }

        for(int j = len-1-i; j >= i+1; j--)
        {
            if( a[j] < a[j-1] )
            {
                temp = a[j];
                a[j] = a[j-1];
                a[j-1] = temp;
                swap = true;
            }
        }
        if( false == swap)
        {
            break;
        }
    }
    return 0;
} 

好了到这里就算优化的差的不多了，先告一段落啦，，，，