Así que tengo una tarea para crear una clase de árbol AVL. Todo funciona perfectamente y no hay fugas, excepto para la función a la combinación de dos árboles de Todos los árboles realizados por esta función causar una fuga de memoria.

La función trabaja como este - crear una matriz ordenada de cada uno de los árboles y fundirlas en una sola matriz. Luego de llamar a una función recursiva que crea un árbol a partir de esta matriz, y que es la función que crea la fuga.

He intentado modificar la función para que devuelva un nodo, pero que no parece ayudar. en el momento en que la función recibe un puntero al nodo que necesita para crear y asigna la memoria no.

Volveré a señalar que los árboles no causar fugas por lo que el problema probablemente está en la combinación de la función y no el destructor.

class AVLNode {
public:
    T key_m;
    S value_m;
    int balance_m;
    AVLNode *left_m;
    AVLNode *right_m;
    AVLNode *parent_m;

    AVLNode(const T &key = T(), const S &value = S(), AVLNode *parent = nullptr) : key_m(key),
                                                             value_m(value),
                                                             balance_m(0),
                                                             parent_m(parent),
                                                             left_m(nullptr),
                                                             right_m(nullptr) {}

    ~AVLNode() {
        delete left_m;
        delete right_m;
    }
}

class AVLTree {

private:
     AVLNode<T,S>* root;
public:

    ~AVLTree(){
     delete root;
     }
}


/*The recursive function which causes the leak. 
it has a parent function I haven't added here since it's not very relevent */
template<class T, class S>
void
AVLTree<T, S>::mergeTrees(AVLNode<T, S> *nodeArr, int start, int end,
                          AVLNode<T, S> *parent, AVLNode<T,S>* nodeToIntialize) {
    if(!nodeArr){
        throw MemError();
    }
    if(start > end){
        return;
    }
    int mid = (start+end)/2;
    T key = nodeArr[mid].key_m;
    S value = nodeArr[mid].value_m;
    nodeToIntialize = new AVLNode<T,S>(key, value, parent); // <- the problem
    (nodeToIntialize)->parent_m = parent;
    mergeTrees(nodeArr, start, mid-1, nodeToIntialize, nodeToIntialize->left_m);
    mergeTrees(nodeArr, mid+1, end, nodeToIntialize, (nodeToIntialize)->right_m);
}

Así que estoy probando este árbol con un programa que genera al azar árboles para mí, y luego los combina y pruebas regulares del árbol de la fusión de los árboles para mantener el equilibrio y el orden, etc. El programa funciona, pero este es el valgrind de salida: https://i.imgur.com/Av885xr.png (Todas las fugas son de la misma línea, me puso de relieve un ejemplo)

En este punto no me importa sólo la reescritura de la función completa, realmente podría utilizar la ayuda. Gracias.