比较排序1：简单比较排序

sorting(按从小到大排序)

一、简单插入排序（插入排序）

稳定排序

把新的值插入到前面已经排好的序列中

c++程序：

// 输入：待排序序列的引用
void InsertSort(vector<int>& sequence)
{
    int len = sequence.size();  // 序列长度
    int key;
    int j;
    for(int i=1; i<len; ++i)
    {
        key = sequence[i];  // 当前待插入值
        j = i-1;  // 前i个元素（即0~i-1）已经排好顺序
        // 找到key应该插入的位置
        while(j>=0)
        {
            if(key<sequence[j])
                sequence[j+1] = sequence[j];
            else
                break;
            --j;
        }
        sequence[j+1] = key;  // 将key插入到已排好的序列中
    }
}

空间复杂度：除了序列本身存储外，额外只需要存储key

                   S(n) = θ(1)   n:序列长度

时间复杂度：

最好情况：待排序序列按正序排列，内层循环（while）中的循环体只执行一次

                时间复杂度 = 外层循环次数（for） x 常数

                即T(n) =(n-1)x常数 =  θ(n)

最坏情况：待排序序列按逆序排列，内层循环（while）中的循环体执行i次

                时间复杂度 = 外层循环次数（for） x 内层循环次数（while） x 常数

                即T(n) = (n + n-1 + ...... +3+2)x常数 = θ(n^2) 

平均情况：T(n) = θ(n^2)

二、冒泡排序（交换排序）

稳定排序

每次循环，依次比较相邻两个元素并适时交换顺序，选出最大的元素放在最后

c++程序：

void BubbleSort(vector<int>& sequence)
{
    int len = sequence.size();  // 序列长度
    int i, j, temp;
    bool flag_swap;
    for(i=1; i<len; ++i)
    {
        cout << i << endl;
        flag_swap = false;
        for(j=0; j<len-i; ++j)
            //依次比较相邻两个元素
            if(sequence[j]>sequence[j+1])
            {
                flag_swap = true;
                temp = sequence[j];
                sequence[j] = sequence[j+1];
                sequence[j+1] = temp;
            }
        //一趟外循环，任意两个相邻元素都没有交换，则序列已经排好序
        if(!flag_swap)
            return;
    }
}

空间复杂度：除了序列本身存储外，额外只需要存储temp(相邻两元素交换时临时存储)

                   S(n) = θ(1)   n:序列长度

时间复杂度：

最好情况：待排序序列按正序排列，则外层循环次数为1，内层循环次数为n-i

                时间复杂度 = 1 x 内层循环次数（for(j)） x 常数

                即T(n) = (n-1)x常数 = θ(n) 

最坏情况：待排序序列按逆序排列，则外层循环次数为n-1,内层循环次数为n-i

                时间复杂度 = 外层循环次数（for(i)） x 内层循环次数（for(j)） x 常数

                即T(n) = (n-1 + n-2 + ...... + 2 + 1)x常数 = θ(n^2) 

平均情况：T(n) = θ(n^2)

三、简单选择排序（选择排序）

不稳定排序

每次循环，第一个数依次与后续每个数比较，找出最小元素放在第一位

c++程序：

void SelectSort(vector<int>& sequence)
{
    int len = sequence.size();
    int i,j,temp;
    for(i=0; i<len-1; ++i)
        //将第i个元素与后续每个元素比较，找出第i小的元素，放在第i位
        for(j=i+1; j<len; ++j)
            if(sequence[i]>sequence[j])
            {
                temp = sequence[i];
                sequence[i] = sequence[j];
                sequence[j] = temp;
            }
}

空间复杂度：除了序列本身存储外，额外只需要存储temp

                   S(n) = θ(1)   n:序列长度

时间复杂度：

任意情况：时间复杂度 = 外层循环次数(for(i)) x 内层循环次数(for(j)) x 常数

                即T(n) = (n-1 + n-2 + ...... + 2 + 1) x 常数 = θ(n^2)