冒泡排序

冒泡排序（Bubble sort）是一种交换排序，它的基本思想是：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

经过第一趟排序，我们可以让第一个最大值冒出来（体现冒泡二字），经过第二趟排序，我们可以让次最大值冒出来...

遍历的趟数是：所需排序数据的长度减一

交换的次数是：所需排序数据的长度减一，并减去当前有序的数据个数

核心代码（C实现）

void swap(int arr[], int i, int j)
{
    int temp;

    assert(arr!=NULL);

    temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

void BubbleSort(int arr[], int len)
{
    int i;
    int j;
    //对局部有序进行优化的标记
    int flag;

    //检测参数
    assert(arr!=NULL && len>0);

    //控制循环趟数，6个数进行冒泡排序，只需要5趟，所以减1 
    for(i=0; i<len-1; ++i)
    {
        flag = -1;

        //遍历需要进行排序的元素 
        for(j=0; j<len-1-i; ++j)
        {
            if(arr[j] > arr[j+1])
            {
                //交换
                swap(arr, j, j+1);

                //标记 
                flag = j+1;
            }
        }

        //如果所给数据是有序的，直接返回 
        if(-1 == flag)
        {
            return;
        }

        //局部有序的优化 
        i = len-flag-1;
    }
}

核心代码（C++实现） 

template <typename T>
void swap(T& x, T& y)
{
    T temp = x;
    x = y;
    y = temp;
}

template <typename T>
void bubbleSort(T array[], int length)
{
    if ((NULL == array) || length < 2) {
        return;
    }

    int flag = -1; // 标记排序的位置，用于优化冒泡排序
    int i = 0;
    while (i < length-1)
    {
        flag = -1;
        for (int j = 0; j < length-1-i; ++j)
        {
            if (array[j] > array[j+1])
            {
                swap(array[j], array[j+1]);
                flag = j+1; // 标记j+1位置，此时flag表示：flag位置及后面的元素都是有序的，
                            // 那么还需要排序的元素个数是flag个。
            }
        }
        if (-1 == flag) {
            return;
        }
        i = length-flag; // 遍历的趟数（length-1-i）等于（flag-1），推出 i = length-flag
　　　　　　　　　　   　　 // 另一种推导方式（这个更便于理解）：由上面的for循环可知，i表示有序元素的个数，那么
                        // i等于总的元素个数（length）减去无序的元素个数（flag），即 i = length-flag
    }
}

算法分析：
　　最好时间复杂度：O(n)　　所给数据是有序的，遍历一遍数据就可以了。
　　平均时间复杂度：O(n^2)
　　最坏时间复杂度：O(n^2)
　　　　空间复杂度：O(1)
　　　　　　稳定性：稳定