排序算法之冒泡排序

冒泡排序就是把小的元素往前调或者把大的元素往后调，即小的元素逐渐“冒泡”，较大的元素逐渐“沉底”。其中比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，则不交换；如果两个元素不相等，则需要交换。由于交换是相邻元素，则两个相等元素的前后顺序并没有发生变化，所以冒泡排序是一种稳定排序算法。
首先介绍一种类似于冒泡排序的算法，实际交换为i和j的元素，而不是j和j + 1 的元素，从而导致算法不稳定，即两个相等元素的前后顺序发生变化。
1.算法思路：
设待排序数组为a
，设置两个标志i和j，i表示当前比较元素，j表示逐个与i元素相比较的下标。假设交换为较小的冒泡，即i次循环结果第i个较小的元素确定。
2.举例说明：
设数组a的元素为：1 8 4 6 9 4(*) 2 (说明：(*)是为了区别两个相等元素
第一趟：i = 0 ;j 从1开始; 因a[i] < a[j],则j++; 其结果为：1 8 4 6 9 4(*) 2
第二趟：i = 1;j 从2开始;a[i] = 8;a[j] = 4;因a[i] > a[j]，交换为：a[i] = 4;a[j] = 8;j++;最终为：1 2 8 6 9 4(*) 4 （不稳定）
.......
第六趟：i = 5;结果为：1 2 4(*) 4 6 8 9

程序如下：

void BubbleSort(int a[],int n)
{
int i,j;
for(i = 0;i < n - 1;i++)
{
for(j = i + 1; j < n;j++)
{
if(a[i] > a[j])
{
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
}

其次给出一般冒泡排序算法的例子：
第一趟：1 8 4 6 9 4(*) 2 -> 1 4 6 84(*) 2 9

第二趟：1 4 6 8 4(*) 2 9 -> 1 4 64(*) 2 8 9
......
第六趟：1 4 2 4(*) 6 8 9 -> 1 2 4 4(*) 6 8 9

程序如下：
void BubbleSort2(int a[],int n)
{
int i,j;
for(i = 0;i < n - 1;i++)
{
for(j =0; j < n - i - 2;j++)
{
if(a[j] > a[j+1])
{
int temp = a[j]
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
}

再次对于一些基本有序的可以通过查看是否有交换来终止循环。

程序如下：
void BubbleSort2(int a[],int n)
{
int i,j;
bool flag = true;
for(i = 0;i < n - 1 && flag;i++)
{
flag = false;
for(j =0; j < n - i - 2;j++)
{
if(a[j] > a[j+1])
{
int temp = a[j]
a[j] = a[j+1];
a[j+1] = temp;
flag = true;
}
}
}
}

最后，其实我们可以同时从头和从尾开始比较，每次循环可以确定两个元素的位置，从而提高排序的速度。

程序如下：

void BubbleSort3(int a[],int n)
{
int i,j;
int k = 0;
bool flag = true;
while(flag)
{
flag = false;
for(j = k; j < n - 2 - k;j++)
{
i = n - j - 1;
if(a[j] > a[j+1])
{
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
flag = true;
}
if(a[i] < a[i-1])
{
int temp = a[i];
a[i] = a[i-1];
a[i-1] = temp;
flag = true;
}
}
k++;
}

}

总之，冒泡排序是比较简单易懂的排序算法，是需要基本掌握的。