冒泡法

基本思想:

<1>

从后往前，逆向比较，每次最小元素就位

在第1趟排序中，逆向依次比较相邻的两个元素,a[n-1],a[n-2],...,a[0]，若发生逆序，则交换顺序。第1次排序结束，最小元素被放在a[0]的位置


在第2趟排序中，逆向依次比较相邻的两个元素,a[n-1],a[n-2],...,a[1]，若发生逆序，则交换顺序。第2次排序结束，a[n-1],a[n-2],...,a[1]的最小元素被放在a[1]的位置


在第n-1趟排序，逆向比较相邻元素a[n-1]与a[n-2],若发生逆序，则交换顺序。第n-1次排序结束，a[n-1],a[n-2]的最小元素被放在a[n-2]的位置。至此排序结束

代码：

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

<2>

从前往后，顺向比较，每次最大元素就位
在第1次排序中，顺向依次比较相邻的两个元素，a[0],a[1],...,a[n-1],若逆序，则交换顺序。第1次排序结束，最大的元素交换到a[n-1]的位置


在第2次排序中，顺向依次比较相邻的两个元素，a[0],a[1],...,a[n-2],若逆序，则交换顺序。第1次排序结束，a[0],a[1],...,a[n-2]最大的元素交换到a[n-2]的位置

在第n-1趟排序，顺向比较相邻元素a[n-1]与a[n-2],若发生逆序，则交换顺序。第n-1次排序结束，a[n-1],a[n-2]的最大元素被放在a[n-2]的位置。至此排序结束

代码：

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

其中swap函数用于交换两个元素，为了美观，没有直接写交换元素的代码。编译器优化时，会自动将swap函数定义为inline函数，与直接写交换元素代码应该一样。关于如何确定编译器是否这么处理的，还望大家多多指教。

void swap(int &x,int &y)
{
int tmp=x;
x=y;
y=tmp;
}

冒泡法的比较次数与元素的初始序列无关，但元素移动次数与初始序列有关，时间复杂度是O(n^2)。若在某一次排序中，没有检测到逆序，则所有元素已经有序，算法可以终止。因此改进的冒泡法则如下：

void BubbleSort(int a[],int n)
{
for(int i=0;i<n-1;i++)
 {
bool exchange=false;
for(int j=n-1;j>i;j--)
if(a[j-1]>a[j])
{
exchange=true;
swap(a[j-1],a[j]);
}
if(exchange==false)break;
}
}