排序

排序算法主要有

1. 冒泡排序（时间复杂度为O(n^2)）
2. 选择排序（时间复杂度为O(n^2),单比冒泡排序稍微好点，主要是交换次数少）
3. 直接插入排序（时间复杂度为O(n^2)，比选择排序稍微好点）
   （以上都是O(n^2)的排序，下边排序的复杂度都低于O(n^2)）
4. 希尔排序（插入排序的改进）
5. 堆排序（选择排序的改进）
6. 归并排序
7. 快速排序（交换排序的改进）

1.冒泡排序

冒泡排序是一种交换排序，基本思想就是相邻两位两两比较，如果反序则交换顺序，一直循环直到没有反序为止。如果升序排序的话，也就是每次把当前最小的升到前边当到对应位置。

最简单的排序思路
从第一个位置开始，用第一个位置的数和后边位置比较，如果反序则交换，一次下来确定了第一个位置的数，然后到第二个位置，依次遍历完，即完成排序。
这个算法的效率很低

标准的冒泡排序

void BubbleSort（SqList *L）{    int i,j;    for(i=1;i<L->length;i++)    {        for(j=L->length-1;j>=i;j--)        {            if(L->r[j]>L->[j+1])                swap(L,j,j+1);        }    }}

冒泡排序的优化
当一个序列经过几次交换后就已经有序了，不需要进行接下来的循环，这时我们可以加入一个标志位，判断是否已经有序可以提前退出。

void BubbleSort2（SqList *L）{    int i,j;    bool flag = true;    for(i=1;i<L->length && flag;i++)// for循环退出条件是全部遍历完或者某次比较中没有需要交换顺序的数    {        flag = false;        for(j=L->length-1;j>=i;j--)        {            if(L->r[j]>L->[j+1])            {                swap(L,j,j+1);                flag = true;   // 如果有交换数据则需要将标志位设置为true            }        }    }}

性能分析：
优化后的冒泡排序最好情况下的时间复杂度为O(n)
最差情况时间复杂度为O(n^2);
稳定性：稳定

2.简单选择排序

思路：每次循环找到从当前位置到结束的最小数的下标，然后交换当前位置和记录的最小数位置的数；当前位置从开始一直循环到结束。

void SelectSort(SqList *L){    int i,j,min;    for(i=1;i<L->length;i++)    {        min = i;        // 寻找最小数下标        for(j=i+1;j<=L->length;j++)        {            if(L->r[min]>L->r[j])                min = j;        }        // 交换位置        if(min!=i)        {            swap(L,min,i);        }    }}

性能分析：

复杂度和冒泡排序一样，但是减少了交换次数，所以性能略优于冒泡。

最好情况时间复杂度：O(n^2)
最差情况时间复杂度：O(n^2)
稳定性：不稳定

3.直接插入排序

思路：比较当前数和前边数的大小，找到合适的位置插入当前数，从第二个数开始一直这样插入，直到插完整个序列的数。

void InsertSort(SqList *L){    int i,j;    for(i=2;i<=L->length;i++)// 从第二个数开始依次插入    {        if(L->r[i]<L->r[i-1])        {            L->[0] = L->r[i];// 将当前数记录在r[0]位置            // 循环和前边数比较，确定应该插入的位置，并将该位置后边的数都后移一位            for(j=i-1; L->r[j]>L->r[0];j--)                L->[j+1] = L->r[j];            L->r[j+1] = L->r[0];// 将该数插入对应位置        }    }}

性能分析：
直接插入排序性能略微好于冒泡和选择排序
最好情况时间复杂度：O(n)
最差情况时间复杂度：O(n^2)
稳定性：稳定