算法描述：有数组array，其长度为len。第一轮工作从末尾开始往前比较工作。如果末尾数据比他前一位数据大，则交换他们的位置，否则则不交换。无论本次比较的结果是交还是不交换，这两个数据都遵循了前一个数据比后一个数据大的结果。接下里向前移动一个工作位置，重复以上的操作。这样一轮比较结束。大的数据不断往前移动。如果他是最大的，就会一直往前移动。如果不是则说明数组前面中还有比他大的数据，该数据也尝试向前交换移动直到结束或者也遇到有更大的数据。一轮结束以后，本轮中最大的数据就到了最前面。这个数据就占领这个位置了。下一轮我们的工作位置又回到最后一位，由于第一个位置已经被占领了，所以这个位置我们就排除在本轮工作的范围内。以此类推，直到工作区间最后长度只剩下2个数据为止。

例子演示：

数组：4 3 2 5 1，长度：5

第一轮：

• 4 3 2 5 1→4 3 2 5 1 比较最后一位1是否比前一位5大，否，则不移动
• 4 3 2 5 1→4 3 5 2 1 移动工作位置到前一位，比较5是否比2大，是，交换
• 4 3 5 2 1→4 5 3 2 1 移动工作位置到前一位，比较5是否比3大，是，交换
• 4 5 3 2 1→5 4 3 2 1 移动工作位置到前一位，比较5是否比4大，是，交换，第一个位置被占领

第二轮

• 5 4 3 2 1→5 4 3 2 1 比较最后一位1是否比前一位2大，否，则不移动
• 5 4 3 2 1→5 4 3 2 1 移动工作位置到前一位，比较2是否比前一位3大，否，则不移动
• 5 4 3 2 1→5 4 3 2 1 移动工作位置到前一位，比较3是否比前一位4大，否，则不移动，第二个位置被占领

第三轮：

• 5 4 3 2 1→5 4 3 2 1 比较最后一位1是否比前一位2大，否，则不移动
• 5 4 3 2 1→5 4 3 2 1 移动工作位置到前一位，比较2是否比前一位3大，否，则不移动，第三个位置被占领

第四轮：

• 5 4 3 2 1→5 4 3 2 1 比较最后一位1是否比前一位2大，否，则不移动，第四个位置被占领

总结：冒泡算法优点：简单，实现容易，运算稳定，穷举即可。缺点：存在浪费现象，比如以上这个例子，在这个数组中第一轮结束数组其实已经排完顺序了。后面还要继续计算。可以改良，但是即使改良还是存在不必要的运算。

代码清单：

#include <iostream>

void bubbleSort(int *array, int len)
{
    int i, j;
    for (i = 0; i < len - 1; i++)
    {
        for (j = 0; j < len - i - 1; j++)
        {
            if (array[j] > array[j + 1])
            {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

int main()
{
    int array[] = {1, 7, 9, 2, 0};
    printf("array before bubble sort=");
    int i;
    for (i = 0; i < sizeof(array)/sizeof(array[0]); i++)
    {
        printf("%d ", array[i]);
    }
    printf("\n");
    bubbleSort(array, sizeof(array));
    printf("array after  bubble sort=");
    for (i = 0; i < sizeof(array)/sizeof(array[0]); i++)
    {
        printf("%d ", array[i]);
    }
    return 0;
}