C# C语言中自顶向下合并排序的实现#

我正在尝试用C#实现自顶向下的合并排序算法，如上所述。下面的实现就是我想到的，但是，它似乎没有正确地对数组排序。我已经检查了调试程序几次，但无法找出代码哪里出错了。任何帮助都将不胜感激

using System;

class MergeSort
{
    static void Main()
    {
        int[] A = { 4, 3, 2, 1 };
        int lastIndex = A.Length - 1;
        int[] B = new int[A.Length];
        Array.Copy(A, B, A.Length);
        MergeSortNumbers(B, 0, lastIndex, A);
        foreach (var item in A)
        {
            Console.WriteLine("{0} ", item);
        }
    }

    private static void MergeSortNumbers(int[] B, int iStart, int iEnd, int[] A)
    {
        int iMiddle = (iStart + iEnd) / 2;
        if ((iEnd - iStart) < 2)
        {
            // Merge(B, iStart, iMiddle, iEnd, A);
            return;
        }
        MergeSortNumbers(A, iStart, iMiddle - 1, B);
        MergeSortNumbers(A, iMiddle, iEnd, B);
        Merge(B, iStart, iMiddle, iEnd, A);
    }

    private static void Merge(int[] A, int iStart, int iMiddle, int iEnd, int[] B)
    {
        int i = iStart;
        int j = iMiddle;

        for (int k = iStart; k < iEnd; k++)
        {
            if (i < iMiddle && (j >= iEnd || A[i] <= A[j]))
            {
                B[k] = A[i];
                i = i + 1;
            }
            else
            {
                B[k] = A[j];
                j = j + 1;
            }
        }
    }
}

使用系统；
类合并排序
{
静态void Main（）
{
int[]A={4,3,2,1}；
int lastIndex=A.长度-1；
int[]B=新的int[A.长度]；
数组.副本（A，B，A.长度）；
合并序号（B，0，lastIndex，A）；
foreach（A中的var项目）
{
Console.WriteLine（“{0}”，项）；
}
}
私有静态void合并序号（int[]B，int-iStart，int-iEnd，int[]A）
{
int-imidle=（iStart+iEnd）/2；
如果（（iEnd-iStart）<2）
{
//合并（B、iStart、IMIDLE、iEnd、A）；
返回；
}
合并序号（A、iStart、IMIDLE-1、B）；
合并序号（A、IMIDLE、iEnd、B）；
合并（B、iStart、IMIDLE、iEnd、A）；
}
私有静态无效合并（int[]A、int-iStart、int-imidle、int-iEnd、int[]B）
{
int i=iStart；
int j=imidle；
for（int k=iStart；k如果（i=iEnd | A[i]有两个问题。你应该知道，
iEnd
是排他性的。这意味着
iEnd
本身在索引中不考虑。这是因为合并方法中的
j>=iEnd
条件和MergeSortNumber方法中的
（iEnd-iStart）<2

imidle
对左侧也是独占的。因为合并方法中的
i
条件

所以基本上不要将端点递减1。（如果端点包含在内，则只递减1）

static void Main（）
{
int[]A={4,3,2,1}；
int[]B=新的int[A.长度]；
数组.副本（A，B，A.长度）；
MergeSortNumbers（B，0，A.长度，A）；//不要减少A.长度
foreach（A中的var项目）
{
Console.WriteLine（“{0}”，项）；
}
}
私有静态void合并序号（int[]B，int-iStart，int-iEnd，int[]A）
{
如果（（iEnd-iStart）<2）返回；
int-imidle=（iStart+iEnd）/2；
MergeSortNumbers（A，iStart，imidle，B）；//不要减少imidle
合并序号（A、IMIDLE、iEnd、B）；
合并（B、iStart、IMIDLE、iEnd、A）；
}
私有静态无效合并（int[]A、int-iStart、int-imidle、int-iEnd、int[]B）
{
int i=iStart；
int j=imidle；
for（int k=iStart；k=iEnd|A[i]
static void Main()
{
    int[] A = { 4, 3, 2, 1 };
    int[] B = new int[A.Length];
    Array.Copy(A, B, A.Length);
    MergeSortNumbers(B, 0, A.Length, A); // Do not decrement A.Length
    foreach (var item in A)
    {
        Console.WriteLine("{0} ", item);
    }
}

private static void MergeSortNumbers(int[] B, int iStart, int iEnd, int[] A)
{
    if ((iEnd - iStart) < 2) return;

    int iMiddle = (iStart + iEnd) / 2;
    MergeSortNumbers(A, iStart, iMiddle, B); // Do Not decrement iMiddle
    MergeSortNumbers(A, iMiddle, iEnd, B);
    Merge(B, iStart, iMiddle, iEnd, A);
}

private static void Merge(int[] A, int iStart, int iMiddle, int iEnd, int[] B)
{
    int i = iStart;
    int j = iMiddle;

    for (int k = iStart; k < iEnd; k++)
    {
        if (i < iMiddle && (j >= iEnd || A[i] <= A[j]))
        {
            B[k] = A[i++];
        }
        else
        {
            B[k] = A[j++];
        }
    }
}