冒泡排序是一种交换排序，实现比较简单，其原始版本如下
void bubsort(int a[], int n)
{
int temp;
for (int i=0; i<n-1; i++)
{
for (int j=0; j<n-i; j++)
if (a[j] > a[j+1])
{
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
而我们讨论的重点是它的优化。
概念
有序数组：指按一定顺序排列的数组；
无序数组：指不满足一定排列顺序的数组；
对于冒泡排序，本文默认为前小后大排序方式，
也就是在排序过程中被操作数组的前面是无序的，后面逐渐变成有序，直到整个数组有序。
优化一 插旗优化
插旗优化思路很简单明了，就是在数据排序完成后插个旗，表明数据是否已经有序，进而避免多余的循环。例如有数组12354
显然，第二次的时候就可以结束循环了。
void bubsort(int a[], int n)
{
int temp, flag;
for (int i=0; i<n-1; i++)
{
flag = 0;//设置旗子
for (int j=0; j<n-i; j++)
if (a[j] > a[j+1])
{
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
flag = 1;//插上旗子
}
if (flag==0)//判断有无旗子
break;//终止循环
}
}
优化二 封顶优化
排序的时候，发生数组无序但数组后半部分有序的情况，这时后面有序部分可封起来，作为下一轮循环的顶，否则每次循环会多浪费时间去扫描这些有序部分。例如
数组32145.
一 3 2 1 4 5
二 2 1 3 4 5
三 1 2 3 4 5
四 1 2 3 4 5
显然，45重复扫描了多次。
void bubsort(int a[], int n)
{
int temp, p, last = n - 1;//last是后半有序部分最小值的位置
//，即无序部分的顶。
for (int i = 0; i < last; i++)
{
for (int j = 0; j < last; j++)
if (a[j] > a[j + 1])
{
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
p = j;//通过每次数据交换更新顶部，直到数据不交换就
//意味着有序，此时p即为无序数组顶部。
}
last = p;//封顶。
}
}
# 优化三
冒泡小变体-双向冒泡
对于双向冒泡的原理也容易理解，就是同时从两边对数组进行扫描和交换，一次找出最大值和最小值。
void bubsort(int a[], int n)
{
int hi, lo， top;
hi = n-1;//设置哨兵-最大
lo = 0;//设置哨兵-最小
while (lo<hi)
{
for (int i=lo; i<hi; i++)//从前到后扫描
if (a[i]>a[i+1])
{
int temp = a[i];
a[i] = a[i+1];
a[i+1] = temp;
top = i;//标记顶
}
hi = top;//封顶
for (int j=hi; j>lo; j--)//从后到前扫描
if (a[hi]<a[hi-1])
{
int temp = a[j];
a[j] = a[j-1];
a[j-1] = temp;
top = j;//标记底
}
lo = top;//封底
}
}
等等，分析一下时间复杂度，虽然双向冒泡的外部循环少了执行次数，但内部变成两次循环，和单向冒泡都是O（n^2），到底在什么地方优化呢？
我们再看看我做的简单的对照表
| Column 1 | Column 2 |
|---|---|
| 0.219 | 26.246 |
| 0.19 | 21.106 |
| 0.16 | 18.413 |
依次为单向冒泡，单向冒泡（插旗+封顶），双向冒泡在数组大小分别为10000,100000时运行的时间。
注：表格时间均为三次运行的中值，使用rand()，数据从实验方面来说不严谨，但这里只为说明双向冒泡确实做到了优化。
为什么双向能做到优化呢？
很简单
双向冒泡排序自带了封顶优化（封底从另一方面也可以看作封顶）。也就是说双向的优化和封顶优化的原理相同，甚至双向不仅封顶，而且还封底，比单向封顶还要好一点。
双向冒泡（插旗优化）
相信看到题目，大家马上就能想到原理，这里就不赘述了。
void bubsort(int a[], int n)
{
int hi, lo, flag, top;
hi = n-1;
lo = 0;
while (lo<hi)
{
flag = 0;
for (int i=lo; i<hi; i++)
if (a[i]>a[i+1])
{
int temp = a[i];
a[i] = a[i+1];
a[i+1] = temp;
flag=1;
top = i;
}
hi = top;
if (flag==0)
break;
flag = 0;
for (int j=hi; j>lo; j--)
if (a[j]<a[j-1])
{
int temp = a[j];
a[j] = a[j-1];
a[j-1] = temp;
flag = 1;
top = j;
}
lo = top;
if (flag==0)
break;
flag = 0;
}
}
这就是冒泡排序最终优化版本（双向插旗）了。
————————————————
注意！原版冒泡排序的时间是稳定的，但我们所做的优化是对数据有点敏感的，所以优化后的版本虽然时间复杂度还是O（n^2），但如果用测试的时候，运行时长会随着数据的变化而变化。