非递归分治法排序 MergeSort without recursion

void Merge(int L, int R, int Mid, int A[], int Tmp[])
{
        int i, TmpIndex = L, LIndex = L, RIndex = Mid+1;

        while(LIndex <= Mid && RIndex <= R)
                Tmp[TmpIndex ++] = A[LIndex] <= A[RIndex] ? A[LIndex ++] : A[RIndex ++];

        while(LIndex <= Mid)
                Tmp[TmpIndex ++] = A[LIndex ++];
        while(RIndex <= R)
                Tmp[TmpIndex ++] = A[RIndex ++];

        for(i=L; i<=R; i++)
                A[i] = Tmp[i];
}

void MergeSort(int A[], int N)
{
        int *Tmp = (int *)malloc( N * sizeof(int) );
        int i, j, R, Mid;
        for(i=2; i<N; i <<= 1)
        {
                for(j=0; j<=N-1; j+=i)
                {
                        Mid = j + (i>>1) - 1;
                        if(j+i-1 > N-1) 
                                R = N-1;
                        else 
                                R = j+i-1;
                        Merge(j, R, Mid, A, Tmp);
                }
        }
        Merge(0, N-1, (i>>1)-1, A, Tmp);
        free(Tmp);
}