C++ 合并排序重复相同的数字

我试图重新学习我的基本CS技能，并尝试实现一个简单的合并排序算法。我不知道我做错了什么，但代码只是重复保存相同的数字。这是我得到的输出：

我用这个网站作为指导：我确认它确实可以正常工作（稍加修改）。有人介意分享我代码中任何明显的错误吗

void Merge(int arr[], int left, int right, int pivot)
{

    int leftCount = pivot - left + 1;
    int rightCount = right - pivot;

    int *leftSec = new int[leftCount];
    int *rightSec = new int[rightCount];

    for (int i = 0; i < leftCount; i++)
    {
        leftSec[i] = arr[left + i];
    }
    for (int j = 0; j < rightCount; j++)
    {
        rightSec[j] = arr[pivot + 1 + j];
    }

    int i = 0;
    int j = 0;
    int k = leftCount;
    while(i < leftCount && j < rightCount)
    {
        if (leftSec[i] <= leftSec[j])
        {
            arr[k] = leftSec[i];
            i++;
        }
        else
        {
            arr[k] = rightSec[j];
            j++;
        }
        k++;
    }
    while (i < leftCount)
    {
        arr[k] = leftSec[i];
        i++;
        k++;
    }
    while (j < rightCount)
    {
        arr[k] = rightSec[j];
        j++;
        k++;
    }
    delete[] leftSec;
    delete[] rightSec;
}

void MergeSort(int arr[], int left, int right)
{
    if (left < right)
    {
        int pivot = (left + right) / 2;
        MergeSort(arr, left, pivot);
        MergeSort(arr, pivot + 1, right);
        Merge(arr, left, right, pivot);
    }
}

int _tmain(int argc, _TCHAR* argv[])
{
    int t;
    int unsortedArray[] = { 94, 384, 934, 3, 56, 57, 94, 60, 90 };
    int arrayLength = sizeof(unsortedArray) / sizeof(int);
    printArray(unsortedArray, arrayLength);
    MergeSort(unsortedArray, 0, arrayLength);
    printArray(unsortedArray, arrayLength);
    cin >> t;
    return 0;
}

void合并（int-arr[]，int-left，int-right，int-pivot）
{
int leftCount=枢轴-左+1；
int rightCount=右枢轴；
int*leftSec=newint[leftCount]；
int*rightSec=新的int[rightCount]；
for（int i=0；it；
返回0；
}

您的代码有很多问题。它在函数merge（）中有内存泄漏：您使用new，删除在哪里？其次是

while(j < rightCount) //this is never executed, you can double check this by drawing the mergesort tree and a perform the steps.

while（j

抱歉花了这么长时间。无论如何，这是您的算法：）

void合并树（int*arr，int-left，int-mid，int-right）{
//左右两侧的新阵列
int*leftArr=newint[mid-left+1]；
int*rightArr=新int[right-mid]；
//在新数组0…n之间创建映射，其中n=左计数器/右计数器和左…右计数器
int leftCounter=mid-left+1；
int rightCounter=右-中；
int i=0；
int j=左；
//复制阵列
对于（i=0；i如果（leftArr[i]您有内存泄漏，您使用new，以后不删除…@KostasRim很好，我会解决这个问题。我正在创建一个答案，您的代码有很多问题，我会给您一个新的实现，我也会指出您的错误：）如果我复制并粘贴你的代码，你的代码就可以完美地工作。我试图将你的更改集成到我的代码中，但仍然得到不正确的输出。不过，我会给你答案。谢谢！
void mergeTree(int* arr, int left, int mid, int right) {
    //new arrays left and right



    int* leftArr = new int[mid - left + 1];
    int* rightArr = new int[right - mid];

    //create a map between the new arrays 0...n where n = left counter/right counter and left...right
    int leftCounter = mid - left + 1;
    int rightCounter = right - mid;

    int i = 0;
    int j = left;
    //copy the arrays
    for(i = 0; i < leftCounter; i++) {
        leftArr[i] = arr[j];
        j++;
    }
    j = mid + 1;
    for(i = 0; i < rightCounter; i++) {
        rightArr[i] = arr[j];
        j++;
    }

    i = 0;
    j = 0;
    int k = left;

    while(i < leftCounter && j < rightCounter) {
        if(leftArr[i] <= rightArr[j]) {
            arr[k] = leftArr[i];
            i++;
        }
        else {
            arr[k] = rightArr[j];
            j++;
        }
        k++;
    }

    while(i < leftCounter) {
        arr[k] = leftArr[i];
        i++;
        k++;
    }

    delete[] leftArr;
    delete[] rightArr;

}

 void mergeSort(int* arr, int left, int right) {
    if(left < right) {
        int mid = (left + right) / 2;
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        mergeTree(arr, left, mid, right);
    }
}

mergesort(arr, 0, n-1)...