插入、冒泡、选择与shell排序

插入、冒泡与选择这三个排序算法的平均时间复杂度都是O(n^2)，插入和冒泡的最优时间复杂度都是O(n)，选择排序的最优时间复杂度还是O(n^2)，三者最差的时间复杂度都是O(n^2)。其中插入与冒泡排序是稳定的，选择排序是不稳定的。

排序算法稳定，是指能保证排序前2个相等的数在序列的前后位置顺序和排序后他们两个的前后位置顺序相同。即：a=b,排序前a在b之前，排序后a还应该在b之前。(相对位置)

一、插入排序

思想：默认第一个元素为有序序列，将其后的元素与该序列中的元素进行比较后，进行插入排序

void insertSort(vector<int> &a)
{
    int n = a.size();
    for (int i = 1; i < n; i++)            //从第二个元素开始
    {
        int num = a[i];                    //需要插入的元素
        int j = i-1;
        for (; j>=0 && num<a[j]; j--)        //从小到大排序
            a[j+1] = a[j];
        a[j+1] = num;
    }
}

 

二、冒泡排序

思想：两两比较，将最小或最大的元素推到数组中的顶部或底部

void bubbleSort(vector<int> &a)
{
    for (int i = 0; i < a.size()-1; i++)        //冒泡总趟数比元素个数少1
    {
        for (int j = 0; j < a.size()-1-i; j++)    //当前所需趟数
        {
            if (a[j] > a[j+1])        //将大的元素推到数组尾部
                swap(a[j], a[j+1]);
        }
    }
}

三、选择排序

思想：每次选出数组中最大或者最小的元素放入到数组的头部或尾部

void selectSort(vector<int> &a)
{
    for (int i = 0; i < a.size(); i++)
    {
        int min = INT_MIN;
        int Index = -1;
        for (int j = i; j < a.size(); j++)
        {
            if (min > a[j])
            {
                min = a[j];
                Index = j;
            }
        }
        swap(a[i], a[Index]);
    }
}

四、shell排序

思想：shell排序是将序列分成多个子序列，然后分别对每个子序列进行插入排序

一种可能的实现方法：将数组分成n/2个长度为2的子序列，每个序列中两个元素下标相差n/2

void shellSort(vector<int> &a)
{
    int n = a.size();
    for (int gap = n/2; gap > 0; gap/=2)
    {
        /*每个组由两个数组成，两个数之间的间距为gap*/
        for (int i = 0; i < gap; i++)
        {
            for (int j = i+gap; j < n; j+=gap)
            {
                if (a[j] < a[j-gap])
                {
                    /*插入排序*/
                    int num = a[j];
                    int k = j-gap;
                    for (; k>=0 && num<a[k]; k-=gap)
                        a[k+gap] = a[k];
                    a[k+gap] = num;
                }
            }
        }
    }
}