归并排序（非递归）

接着上篇文章归并排序（递归）来探讨下，归并排序的非递归实现。

归并排序的非递归实现：
（1）将两个相邻的有序序列归并成一个有序序列，我们称为“一次归并”。
（2）“一趟归并”，是多次执行“一次归并”的结果。在“一趟归并”中，除最后一个有序序列外，其他有序序列中记录的个数（称为序列长度）相同，用h表示。现在的任务是把若干个相邻的长度为h的有序序列和最后一个长度有可能小于h的有序序列进行两两归并，把结果存放到temp[1]～temp[n]中（注意：我们是从下标1开始存放排序序列的）。为此，设参数i，指向待归并序列的第一个记录，初始时，i=1，显然归并的步长应是2h。在归并过程中，有以下三种情况：
<1> 若 i <= n - 2h + 1，则表示待归并的两个相邻有序序列的长度均为h，执行“一次归并”，完成后i加2h，准备进行下一次“一次归并”。
<2> 若 i < n - h + 1，则表示仍有两个相邻有序序列，一个长度为h，另一个长度小于h，则执行这两个有序序列的归并，完成后退出“一趟归并‘。
<3> 若 i >= n - h + 1，则表明只剩下一个有序序列，直接将该有序序列送到temp数组的相应位置，完成后退出”一趟排序“。

综上，”一趟归并排序“的算法如下：

void mergePass(int arr[], int n, int h, int temp[]) // 从下标1开始存放待排序序列
{
    int i = 1;

    while (i <= n - 2*h + 1) // 待归并记录至少有两个长度为h的子序列。
    {
        mergeArray(arr, i, i + h - 1, i + 2*h - 1, temp);
        i += 2*h;
    }

    if (i < n - h + 1) // 此时 n - 2*h + 1 < i < n - h + 1，待归并序列中有一个长度小于h。
        mergeArray(arr, i, i + h - 1, n, temp);
    else               // 此时 i >= n - h + 1，待归并序列中只剩一个子序列。
        for (int k = i; k <= n; k++)
            temp[k] = arr[k];
}

（3）如何控制“二路归并排序的非递归实现”的结束？开始时，有序序列的长度为1，结束时，有序序列的长度为n，因此，可以用有序序列的长度来控制排序过程的结束。算法如下：

void mergeSort2(int arr[], int n, int temp[]) // 从下标1开始存放待排序序列
{
    int h = 1;  // 初始时子序列长度为1

    while (h < n)
    {
        mergePass(arr, n, h, temp);
        h = 2*h;
    }
}

完整代码如下：

#include <iostream>

// 将2个相邻的有序数组arr[first...mid]和arr[mid+1...last]归并成一个有序数组temp[first, last]。
// 这是二路归并的核心操作，在归并过程中，可能会破坏原来的有序序列，所以，将归并的结果存入另外一个数组(temp[])中。
void mergeArray(int arr[],int first,int mid,int last, int temp[])
{
    int i = first,j = mid+1;
    int k = 0;

    // 通过比较i和j所指记录的关键码，取出较小者作为归并结果存入k所指位置，直至两个有序数组之一的所有记录都取完，再将另外一个有序数组的剩余记录顺序送到归并后的有序数组(temp[])中。
    while(i <= mid && j <= last)
    {
        if (arr[i] <= arr[j])
            temp[k++] = arr[i++];
        else
            temp[k++] = arr[j++];

    }


    while (i <= mid)
        temp[k++] = arr[i++]; // 若经过上述循环后，arr[j]中的元素都取完，而arr[i]中还有剩余元素，那么将arr[i]中的元素顺序的存入归并后的有序数组temp中。


    while (j <= last)
        temp[k++] = arr[j++]; // 若经过上述循环后，arr[i]中的元素都取完，而arr[j]中还有剩余元素，那么将arr[j]中的元素顺序的存入归并后的有序数组temp中。

    // 将排好序的临时数组重新放置到原数组arr中
    for (i = 0;i < k;i++)
        arr[first+i] = temp[i];
}


void mergePass(int arr[], int n, int h, int temp[]) // 从下标1开始存放待排序序列
{
    int i = 1;

    while (i <= n - 2*h + 1) // 待归并记录至少有两个长度为h的子序列。
    {
        mergeArray(arr, i, i + h - 1, i + 2*h - 1, temp);
        i += 2*h;
    }

    if (i < n - h + 1) // 此时 n - 2*h + 1 < i < n - h + 1，待归并序列中有一个长度小于h。
        mergeArray(arr, i, i + h - 1, n, temp);
    else               // 此时 i >= n - h + 1，待归并序列中只剩一个子序列。
        for (int k = i; k <= n; k++)
            temp[k] = arr[k];
}


// 如果想从下标0开始存放待排序序列，应对mergePass函数做如下修改。
//void mergePass(int arr[], int n, int h, int temp[])
//{
//    int i = 0;
//    
//    while (i <= n - 2*h)
//    {
//        mergeArray(arr, i, i + h - 1, i + 2*h - 1, temp);
//        i += 2*h;
//    }
//    
//    if (i < n - h)
//        mergeArray(arr, i, i + h - 1, n, temp);
//    else
//        for (int k = i; k <= n; k++)
//            temp[k] = arr[k];
//}



void mergeSort2(int arr[], int n, int temp[]) // 从下标1开始存放待排序序列
{
    int h = 1;  // 初始时子序列长度为1

    while (h < n)
    {
        mergePass(arr, n, h, temp);
        h = 2*h;
    }
}


// 使用归并排序
void MergeS(int arr[],int n)
{
    int *p = new int[n]; // 在归并过程中，可能会破坏原来的有序序列，所以，将归并的结果存入该数组中。也可使用 (int *)malloc((high-low+1)*sizeof(int));

    if(p == NULL) return;

    mergeSort2(arr, n-1, p);
    delete [] p;
}

int main(int argc, const char * argv[]) {

    int arr[10] = {1000,2,1,3,7,6,8,9,5,4}; // 注意：我们是从下标1开始存放待排序序列，也就是说1000不参与排序。

    MergeS(arr, 10);

    for(int i = 0;i < 10;i++) // 我们是从下标1开始存放待排序序列，所以打印时，下标的起始值为1。
        printf("%d ",arr[i]);

    printf("\n");

    return 0;
}