C++ 使用动态数组合并排序

我试图实现一个函数mergeSort，它返回intervalo\t类型的动态数组。实际上，这个函数运行得很好，我遇到的问题是，当我运行Valgrind检查内存丢失时，结果发现我的内存丢失了很多

间隔定义：

struct intervalo_t {
    nat inicio;
    nat fin;
};

代码如下：

intervalo_t* mergeSort(intervalo_t *intervalos, nat n)
{   
    intervalo_t* ret=new intervalo_t[n];
    if(n==2){
        if (intervalos[0].fin>intervalos[1].fin){
            ret[0]=intervalos[1];
            ret[1]=intervalos[0];
        }else{
            ret[0]=intervalos[0];
            ret[1]=intervalos[1];
        }
    //caso base
    }else if (n==1){
        ret[0]=intervalos[0];
    //caso base
    }else{
        nat k=0;        
        if((n%2)!=0){
            k=1;
        }//Si es par o no
        intervalo_t* interA =new intervalo_t[n/2 + k];
        intervalo_t* interB =new intervalo_t[n/2];
        for (nat i=0; i<n/2; i++){
            interA[i]=intervalos[i];
            interB[i]=intervalos[i+(n/2)];
        }//for
        if (k==1){ 
            interA[(n/2)]=intervalos[n-1];
        }
        interA=mergeSort(interA, n/2 + k);
        interB=mergeSort(interB, n/2);
        nat i=0;
        nat j=0;
        nat r=0;
        while((i<((n/2)+k)) && (j<(n/2))){
            if (interA[i].fin>interB[j].fin){
                ret[r]=interB[j];
                j++;
            }else{
                ret[r]=interA[i];
                i++;
            }
            r++;
        }
        while(i<(n/2)+k){
            ret[r]=interA[i];
            i++;
            r++;
        }
        while(j<(n/2)){
            ret[r]=interA[j];
            i++;
            j++;
        }
        delete[] interA;
        delete[] interB;
    //recursion
    }
    return ret; 
}

我在valgrind跑步时：

valgrind --leak-check=full ./myFile <test.in

---

提前感谢您的帮助

问题在于您在此处分配的内存：

intervalo_t* interA =new intervalo_t[n/2 + k];
intervalo_t* interB =new intervalo_t[n/2];

在此处覆盖这些指针时发生泄漏：

interA=mergeSort(interA, n/2 + k);
interB=mergeSort(interB, n/2);

为多种目的重用变量很少是一个好主意，因此对递归结果使用单独的变量：

intervalo_t* resultA=mergeSort(interA, n/2 + k);
intervalo_t* resultB=mergeSort(interB, n/2);

然后使用它们进行合并（并记住释放它们）。
我还建议在递归之后立即处理输入，这样您就不会忘记它

---

或者，您可以使用

std:：vector

，省去一些麻烦。

事实上，这个函数运行得很好，--不，它运行得不好。否则将不会有错误报告。请显示。这听起来像是你的函数从来没有被清理过的结果，但是在不使用它的上下文的情况下是不可能的。请考虑使用<代码> STD:：向量< /代码>，而不是分配数组。它避免了所有这些问题--然后在相同的函数中执行此操作--

interA=mergeSort（interA，n/2+k）--这很难维护代码，并且会导致内存泄漏、双重删除错误等。最好的办法是创建一个正确处理内存的动态数组类，如果不能使用
std:：vector
，只需使用它来代替
std:：vector
。谢谢，最后，我使用了最后一个建议，并将函数重新定义为一个void，这样我就不必这样做了：
interA=mergeSort（interA，n/2+k）解决了我的问题，无需创建类
interA=mergeSort(interA, n/2 + k);
interB=mergeSort(interB, n/2);

intervalo_t* resultA=mergeSort(interA, n/2 + k);
intervalo_t* resultB=mergeSort(interB, n/2);