插入排序

Posted 2020-11-25 eimadrigal

直接插入排序

思想

插入排序（Insertion Sort）类似整理桥牌的过程：将右手拿到的牌（未排序）在左手已排序的牌中从后向前扫描，找出对应位置并且插入此牌。
在此过程中，要将已经排序的元素逐步向后挪，给待插入元素腾出空间。

实现

#include <stdio.h>

#define MAXSIZE 100

typedef struct
{
    int a[MAXSIZE + 1];  //a[1]~a[MAXSIZE]存储元素
    int length;
}Sqlist;

/*升序排列*/
void Insertion_Sort(Sqlist* L)
{
    for (int i = 2; i <= L->length; i++)
    {
        int get = L->a[i];
        int j = i - 1;
        while (j > 0 && get < L->a[j])
        {
            L->a[j + 1] = L->a[j];
            j--;
        }
        L->a[j + 1] = get;
    }

}

int main(int argc, char** argv)
{
    Sqlist L;

    scanf("%d", &(L.length));
    for (int i = 1; i <= L.length; i++)
        scanf("%d", &(L.a[i]));

    Insertion_Sort(&L);

    for (int i = 1; i <= L.length; i++)
        printf("%d ", L.a[i]);
    printf("
");

    return 0;
}

复杂度

最好情况：元素全部有序，(N-1)次比较、(0)次交换；复杂度(O(n))。
最坏情况：元素全部逆序，大约(frac{N^2}{2})次比较和(frac{N^2}{2})次交换，复杂度(O(n^2))。
平均情况下：大约(frac{N^2}{4})次比较和(frac{N^2}{4})次交换，复杂度(O(n^2))。

折半插入排序

直接插入排序前面的子序列是有序的，所以如果是顺序表，那么可以先折半查找出元素的待插入位置，再统一移动该位置之后的所有元素：

void insertionSortOptimized(int A[], int n)
{
    //将A[i]插入到合适位置
    for (int i = 1; i < n; i++)
    {
        int tmp = A[i];
        int low = 0, high = i - 1;
        while (low <= high)
        {
            int mid = (low + high) >> 1;
            if (A[mid] > tmp)
            {
                high = mid - 1;
            }
            else
            {
                low = mid + 1;
            }
        }

        //统一后移元素
        for (int j = i - 1; j >= low; j--)
        {
            A[j + 1] = A[j];
        }

        A[low] = tmp;
    }
}

性能：折半插入排序将元素比较次数减少为(O(nlogn))，但是移动次数依然是(O(n^2))，故总的时间复杂度为(O(n^2))。

希尔排序

基本思想：将待排序表分为若干(A[i], A[i+d], A[i+2d]...)子表，(d)称为增量，对这些子表执行直接插入排序，当整个表中的元素“基本有序”时，对整个表来一次直接插入排序。
由于需要快速定位某个子表中的元素，所以只能用于顺序表。

void shellSort(int A[], int n)
{
    //增量序列选之前的一半
    for (int d = n >> 1; d >= 1; d >>= 1)
    {
        //将A[i]插入有序子表
        for (int i = d; i < n; i++)
        {
            if (A[i] < A[i - d])
            {
                int tmp = A[i];
                int j;
                //查找插入位置
                for (j = i - d; j >= 0 && tmp < A[j]; j -= d)
                {
                    A[j + d] = A[j];  //后移
                }
                A[j + d] = tmp;
            }
        }
    }
}

性能：时间复杂度依赖于选取的增量序列，大约是(O(n^{1.3}))，最坏是(O(n^2))。