8645 归并排序（非递归算法）

Description
用函数实现归并排序（非递归算法），并输出每趟排序的结果

输入格式
第一行：键盘输入待排序关键的个数n
第二行：输入n个待排序关键字，用空格分隔数据

输出格式
每行输出每趟排序的结果，数据之间用一个空格分隔

输入样例
10
5 4 8 0 9 3 2 6 7 1

输出样例
4 5 0 8 3 9 2 6 1 7
0 4 5 8 2 3 6 9 1 7
0 2 3 4 5 6 8 9 1 7
0 1 2 3 4 5 6 7 8 9

归并排序递归版：

//递归分治法，无法输出单次排序的的结果
#include <stdio.h>
int n;
void Merge(int* S, int* T, int low, int high);//合并左右区间
void MergeSort(int* S, int* T, int low, int high)
{
    if (low == high)
    {
        T[low] = S[low];
        return;
    }
    int mid = low + (high - low) / 2;//一分为二
    MergeSort(S, T, low, mid);//左边排序
    MergeSort(S, T, mid + 1, high);//右边排序
    Merge(S, T, low, high);//合并区间,将原左右区间按照排序合并到目标数组T中
    int i;
    //更新原数组，让原数组有序,如果不更新，那么递归的时候单个区间的排序结果只在目标数组T中，之后又对未更新的原数组进行处理，即没有排序
    for (i = low; i <= high; i++)
        S[i] = T[i];

    return;
}

void Merge(int* S, int* T, int low, int high)//合并左右区间
{
    int i, j, k, mid = low + ((high-low) >> 1);
    k = i = low, j = mid + 1;
    while (i <= mid && j <= high)
    {
        //        if (S[i] < S[j])
        //            T[k++] = S[i++];
        //        else
        //            T[k++] = S[j++];
            //高级写法
        T[k++] = S[i] < S[j] ? S[i++] : S[j++];
    }
    while (i <= mid)
        T[k++] = S[i++];
    while (j <= high)
        T[k++] = S[j++];

    return;
}

//归并排序递归算法的常用写法
void mergeSort_1(int num[], int T[],int l, int r)
{
    if (l == r)
        return;
    int mid = l + ((r-l)>>1);
    mergeSort_1(num,T,l,mid);
    mergeSort_1(num,T,mid+1,r);

    int i, j, k;
    i = l, j = mid+1, k = l;
    while (i <= mid && j <= r)
        T[k++] = num[i] < num[j] ? num[i++] : num[j++];
    while (i <= mid)
        T[k++] = num[i++];
    while (j <= r)
        T[k++] = num[j++];

    //合并
    for (i = l; i <= r; i++)
        num[i] = T[i];
}

int main()
{
    int S[1000] = { 0 }, T[1000] = { 0 }, i;
    scanf("%d", &n);
    for (i = 0; i < n; i++)
        scanf("%d", &S[i]);
    MergeSort(S, T, 0, n - 1);
//    mergeSort_1(S,T,0,n-1);
    for (i = 0; i < n; i++)
        printf("%d ", T[i]);
    return 0;
}

归并排序非递归版：

//非递归分治法归并排序
#include <stdio.h>
#include <malloc.h>

int min(int x, int y) {
    return x < y ? x : y;
}

void Merge(int arr[], int low, int mid, int high)
{
    //将排序结果放在临时数组，然后将临时数组的值复制给原数组
    int* temp = (int*)malloc(sizeof(int) * (high - low));
    int i = low, j = mid, k = 0;
    while (i < mid && j < high)
        temp[k++] = arr[i] < arr[j] ? arr[i++] : arr[j++];
    while (i < mid)
        temp[k++] = arr[i++];
    while (j < high)
        temp[k++] = arr[j++];

    for (i = 0; i < high - low; i++)
        arr[low+i] = temp[i];
    return;
}
/*
width是距离start的大小，每次×2，模仿递归二分的合并，这个width大小没有限制，
只有width<n这个限制，所以每次width的值是1,2,4,8,16这样
如果是width<=n，输出排序结果的次数就取决于n了，就有可能多输出了一次排序结果
第一次合并的规律是将n个数间隔1分隔合并，第二次合并是将n个数间隔2分隔合并，第三次是间隔4合并
*/

int main()
{
	int n;
	scanf("%d", &n);
	int i, num[1000] = { 0 };
	for (i = 0; i < n; i++)
		scanf("%d", &num[i]);

    int width, start;
    for (width = 1; width < n; width += width) {//分隔宽度，最小宽度为1
        for (start = 0; start < n; start += width * 2) {//遍历数组，分隔区间，进行左右区间的合并
            int low = start, mid = min(start + width, n), high = min(start + width * 2, n);//防止越界
            Merge(num, low, mid, high);
        }
        //输出一趟合并之后数组的结果
        for (i = 0; i < n; i++)
            printf("%d ", num[i]);
        printf("\n");
    }
	return 0;
}