冒泡排序
基本思想：
从一端开始，逐个比较相邻的两个元素，发现倒序则交换。典型的做法是从后往前，或从下往上逐个比较相邻的元素，发现倒序就进行交换。一轮比较之后，一定可以将最大的元素交换到其最终位置上。
 
时间复杂度：O(n*2)
 
稳定性分析：稳定的排序算法

这里说明一下，何为排序算法的稳定性？
排序算法的稳定性就是假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，ri=rj,且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种算法是稳定的。很明显，冒泡排序是稳定的排序算法。

#include <iostream>
using namespace std;

void exchange(int *a,int *b){
    int c;
    c = *a;
    *a = *b;
    *b = c;
}

void bubble_sort(int *A,int length){      //冒泡排序
    int i,j;
    for(i=1;i<length;i++){       //length-1次循环
        for(j=length-1;j>=i;j--){
            if(A[j]<A[j-1])
                exchange(&A[j],&A[j-1]);
        }
    }
}

int main(){
    int A[] = {2,1,3,7,4,5,9,6,8};
    int length = sizeof(A)/sizeof(int);
    bubble_sort(A,length);
    for(int i=0;i<length;i++){
        cout<<A[i]<<" ";
    }
    return 0;
}

这里注意一下，如果某个序列刚开始就是有序的，那么经过一轮循环之后，一次交换也没有执行，那么从直观上来说，就没有必要进行之后的比较了。所以，这里我们提出基于有序序列的冒泡排序，时间复杂度为O(n),也称为改进后的冒泡排序。

基本思想很简单，就是设置一个标记为false，一旦发现交换则将标记置为true，经过一轮循环之后，若标记为false，说明没有进行任何的交换，则结束之后的交换。

void bubble_sort(int *A,int length){      //冒泡排序
    int i,j;
    bool flag = false;
    for(i=1;i<length;i++){       //length-1次循环
        for(j=length-1;j>=i;j--){
            if(A[j]<A[j-1]){
                exchange(&A[j],&A[j-1]);
                flag = true;
            }
        }
        if(flag == false)      //经过一轮循环发现一次都没交换，则不进行后续的比较了
            break;
    }
}