归并排序算法改进-基于link数组和插入排序

归并排序存在的两个问题

1. 归并排序原理此处不做介绍，可自行百度或参考他人博客；
2. 归并排序存在的问题：
   1. 递归层次问题。每次都是递归到只有一个元素时才返回递归；
   2. 元素在数组和辅助数组之间频繁移动。归并过程中，数组元素先移动到辅助数组，再由辅助数组复制到原数组中。

归并排序问题的解决

1. 针对递归层次太深，当right-left<16（一个常数，可指定）时，采用插入排序算法；
2. 针对元素在数组间频繁移动，使用link数组（本质上是一个单向链表，i指arr[i]的下标，link[i]存的是排好序后arr[i]下一个元素的下标）

举个例子：
arr: 5 1 8 2 6 （下标从1开始）,那么link数组为
idx: 0 1 2 3 4 5
link: 2 5 4 0 1 3
即 head(0)->2->4->1->5->3->null，其中null为0（也可以为其他负数）

3. 既然要减少数组间元素的频繁移动，那么插入排序也要采取link数组，即不能直接用插入排序的模板。

实现思路

1. link数组相当于是单向链表，且是全局的，p指向子数组元素最小值在arr中位置；
2. 归并排序函数里，当划分的子数组size<16时使用基于link数组的插入排序；
3. 插入排序思路：

a.先初始化link数组，link[i]=i+1，即将原数组连起来；
b.每次从头开始遍历link数组，当发现元素不满足非减时，就需要改变该位置link指向；
c.从头遍历link数组，找到待插入元素的正确位置，然后改变link指向（思路参见链表的插入和删除）;
d.当遍历完link数组发现有序时，结束循环，同时将本次的head（link[0]）交付给p

4. 归并排序思路：

a.如果两个子数组都有，谁小放谁，同时更新link；
b.当一个子数组用完了，说明这个子数组已经合并好了，那么直接将另一个子数组剩下的link追加到合并好的link尾部即可；
c.最后将本次的head（link[0]）交付给p

5. 其他细节详见代码

代码实现

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N = 100010,INT_Min=-2147483648;
int n;
int arr[N],link[N],pre_link[N];

int find_min(int left, int right) {
    int ans(left);
    for (int i(left+1); i <= right; i++) {
        if (arr[ans] > arr[i]) ans = i;
    }
    return ans;
}

void insert_sort(int left,int right,int& p) {
    if (left >= right) {
        p = left;
        link[left] = 0;
        return;
    }
    int k = 0,i(left);
    link[0] = i;
    for (; i < right; i++) link[i] = i + 1;
    link[i] = 0;
    i = left;
    while (link[i]) {
        int j = i, cnt(0), pre(0);
        while (arr[j] <= arr[link[j]] && link[j]) pre = j, j = link[j], cnt++;
        if (cnt == right - left) break;
        int num = link[j], index = k;
        while (arr[link[index]] <= arr[num] && link[index]) index = link[index];
        if (index < left) {//最前面插入数据
            int temp = link[k],temp_next=link[link[j]];
            link[link[j]] = temp;
            link[k] = link[j];
            link[j] = temp_next;
        }
        else {//中间插入数据
            int temp = link[index],temp_next=link[link[j]];
            link[link[j]] = temp;
            link[index] = num;
            link[j] = temp_next;
        }
        i = link[k];
    }
    p = link[0];
}
void merge(int q,int s,int& p) {
    int i = q, j = s, k = 0;
    while (i&&j) {
        if (arr[i] < arr[j]) {
            link[k] = i;
            k = i;
            i = link[i];
        }
        else {
            link[k] = j;
            k = j;
            j = link[j];
        }
    }
    if (i) {
        link[k] = i;
    }
    else{
        link[k] = j;
    }
    p = link[0];
}
void merge_sort(int left, int right,int& p) {
    if (right - left + 1 < 16) {
        insert_sort(left,right,p);
        return;
    }
    int mid = (right + left) >> 1;
    int q = find_min(left, mid),s=find_min(mid+1,right);
    merge_sort(left, mid,p);
    merge_sort(mid+1, right,p);
    merge(q,s,p);
}
int main() {
    scanf("%d", &n);
    for (int i(1); i <= n; i++)  scanf("%d", &arr[i]);
    arr[0] = INT_Min;
    memset(link, 0, sizeof link);
    int p = find_min(1,n);
    merge_sort(1, n,p);
    while (p) {
        printf("%d ", arr[p]);
        p = link[p];
    }
    printf("\n");
    return 0;
}