O(n^2)的排序(冒泡，选择，插入排序）

1、冒泡排序

基本思想：
两两比较相邻记录的关键字，如果反序则交换，直到没有反序为止。

//基础冒牌排序
void BubbleSort(List *L){
     int i, j;
     for(i = 1; i < L->length; ++i){
        for(j = L->length; j >= i; --j){
            if(L->r[j] > L->r[j+1]){
               swap(L->r[j], L->[j+1]);
            }
        }
     }
}

//优化冒泡排序
void BubbleSort(List *L){
     int i, j;
     bool flag = 1;
     for(i = 1; i < L->length && flag == 1; ++i){
         //如果没有发生数据交换，flag == 0
         //证明已经有序不需要再比较
         flag = 0;
         for(j = L->length; j >= i; --j){
            if(L->r[j] > L->r[j+1]){
               swap(L->r[j], L->[j+1]);
               flag == 1;
            }
     }     
}

冒泡排序的时间复杂度$O(n^2)$ = $\frac{n(n-1)}{2}$。

2、简单选择排序

基本思想：
每趟在n-i+1的记录中选择关键字最小的记录作为和第i个记录交换。

void SelectSort(List *L){
     int i, j, min;
     min = i;
     for(i = 1; i < L->length; ++i){
         for(j = i + 1; j <= L->length; ++j){
             if(L->r[min] > L->r[j]){
                min = j;
             }
        }
        if(i != min){
           swap(L->r[i], L->[j]);
        }
    }
}

时间复杂度：$O(n^2)$ = $\frac{n(n-1)}{2}$。

3、直接插入排序

基本思想：
将一个记录插入到已经有序的表中。

void InsertSort(List *L){
     int i, j;
     for(i = 2; i < L->length; ++i){
        if(L->r[i] < L->r[i-1]){
           L->r[0] = L->L[i];
           for(j = i - 1; L->r[j] > L->[0]; --j){
               L->r[j+1] = L->[j];
           }
           L->r[j+1] = L[0];
        }
     }
}

时间复杂度：$O(n^2)$ $\approx$ $\frac{n^2}{4}$。