C++ 从BST删除节点时释放内存

我在释放内存以删除BST时遇到困难。只要我不包含“delete”关键字，算法本身就可以工作。一旦执行此操作，就会导致以下错误：对象0x7fec6a4026a0的malloc:*错误： 未分配要释放的指针 *在malloc\u error\u break中设置断点以进行调试 中止陷阱：6

这是我的代码，还有一个“delete”关键字。我还包括了我尝试放置delete关键字的其他位置。我知道你必须释放C++中的内存，以防止内存泄漏。我有一种感觉，递归调用可能是导致问题的原因，但我无法确定它

bool AVLTree::deleteNode(string ss, AVLNode* starting){
AVLNode* curr = starting;
AVLNode* parent = starting->parent;

while (curr != nullptr) {
    if (curr->ssn == ss) {
        // Remove leaf
        if (curr->right == nullptr && curr->left == nullptr) {
            // Remove root
            if (parent == nullptr) {
                root = nullptr;
            }
            else if (parent->left == curr) {
                parent->left = nullptr;
            }
            else {
                parent->right = nullptr;
            }
            // IVE TRIED PUTTING DELETE HERE
        }

        // Remove node with two children
        else if (curr->right != nullptr && curr->left != nullptr) {
            // Find succesor
            AVLNode* succ = curr->right;
            while (succ->left != nullptr) {
                succ = succ->left;
            }

            // Copy
            curr->ssn = succ->ssn;
            curr->name = succ->name;

            deleteNode(succ->ssn, curr->right);
        }

        // Remove node with one children
        else {
            // If has left child
            if (curr->left != nullptr) {
                if (parent == nullptr) {
                    root = curr->left;
                }
                else if (parent->left == curr) {
                    parent->left = curr->left;
                }
                else {
                    parent->right = curr->left;
                }
            } 
            else if (curr->right != nullptr) {
                if (parent == nullptr) {
                    root = curr->right;
                }
                else if (parent->left == curr) {
                    parent->left = curr->right;
                }
                else {
                    parent->right = curr->right;
                }
            }
            // IVE TRIED PUTTING DELETE HERE
        }
        delete curr; // THIS IS CAUSING THE PROBLEM
        return true;
    }
    else if ((curr->ssn.compare(ss)) < 0) {
        parent = curr;
        curr = curr->right;
    }
    else {
        parent = curr;
        curr = curr->left;
    }
}

return false;
}


 // Insert function
bool AVLTree::insert(string ss, string na){
    AVLNode* curr = root;

    // Construct new AVL Node 
    AVLNode* newNode = new AVLNode(ss, na);

    // If root is empty, insert
    if (curr == nullptr) {
        root = newNode;
        return true;
    }

    while (curr != nullptr) {
        if (curr->ssn.compare(newNode->ssn) == 0) {
            delete newNode;
            return false;
        } 
        // Go right
        if (newNode->ssn.compare(curr->ssn) > 0) {
            // Check to see if we can insert, currs right child is null
            if (curr->right == nullptr) {
                curr->right = newNode;
                newNode->parent = curr;
                break;
            }
            else {
                curr = curr->right;
            }
        } 
        // Go left
        else {
            // Check to see if we can insert
            if (curr->left == nullptr) {
                curr->left = newNode;
                newNode->parent = curr;
                break;
            } else {
                curr = curr->left; 
            }
        }
    }
    return true;
}

bool AVLTree:：deleteNode（字符串ss，AVLNode*开始）{
AVLNode*curr=启动；
AVLNode*父节点=开始->父节点；
while（curr！=nullptr）{
如果（当前->ssn==ss）{
//去叶
if（curr->right==nullptr&&curr->left==nullptr）{
//除根
如果（父项==nullptr）{
root=nullptr；
}
否则如果（父->左==当前）{
父->左=空PTR；
}
否则{
父->右=nullptr；
}
//我试着把删除放在这里
}
//删除包含两个子节点的节点
否则如果（当前->右侧！=nullptr&&curr->left！=nullptr）{
//找到成功者
AVLNode*succ=当前->右侧；
while（成功->左！=nullptr）{
成功=成功->左；
}
//抄袭
当前->ssn=成功->ssn；
当前->名称=成功->名称；
删除节点（成功->ssn，当前->右侧）；
}
//删除包含一个子节点的节点
否则{
//如果他离开了孩子
如果（当前->左！=nullptr）{
如果（父项==nullptr）{
root=curr->left；
}
否则如果（父->左==当前）{
父项->左=当前->左；
}
否则{
父项->右=当前->左；
}
} 
否则，如果（当前->右侧！=nullptr）{
如果（父项==nullptr）{
root=curr->right；
}
否则如果（父->左==当前）{
父项->左=当前->右；
}
否则{
父项->右=当前->右；
}
}
//我试着把删除放在这里
}
delete curr；//这是导致问题的原因
返回true；
}
如果（（当前->序列号比较（序列号））<0，则为else{
父项=当前值；
当前=当前->右侧；
}
否则{
父项=当前值；
当前=当前->左侧；
}
}
返回false；
}
//插入函数
bool AVLTree:：insert（字符串ss、字符串na）{
AVLNode*curr=根；
//构造新的AVL节点
AVLNode*newNode=新的AVLNode（ss，na）；
//如果root为空，则插入
if（curr==nullptr）{
根=新节点；
返回true；
}
while（curr！=nullptr）{
如果（当前->ssn.比较（新节点->ssn）==0）{
删除新节点；
返回false；
} 
//向右转
如果（newNode->ssn.compare（curr->ssn）>0）{
//检查是否可以插入，currs right child为null
if（curr->right==nullptr）{
curr->right=newNode；
newNode->parent=curr；
打破
}
否则{
当前=当前->右侧；
}
} 
//向左走
否则{
//查看是否可以插入
if（curr->left==nullptr）{
当前->左=新节点；
newNode->parent=curr；
打破
}否则{
当前=当前->左侧；
}
}
}
返回true；
}

创建节点时是否使用

new

？只要我不包含“delete”关键字。一旦我这样做了，它就会导致这个错误——当问题起源于其他地方时，我就把责任归咎于可怜的老

删除
。所有
delete
显示的是1）您没有对分配有
new
的缓冲区的指针发出
delete
，或者2）您的程序很久以前就损坏了内存，
delete
只是内存损坏的症状。@Cuber Yes Iam@PaulMcKenzie我使用“新”分配内存将节点插入BST期间的关键字。@DarshanKalola-然后检查
new
返回的值。它是否与您发出
delete
时使用的值相同？注意，关键字是value，而不是pointer。您可以让
new
返回一个值，然后通过更改值来搞乱指针，然后在该指针上发出
new
，认为一切都会正常。在创建节点时是否使用
new
？只要我不包含“delete”关键字。一旦我这样做了，它就会导致这个错误——当问题起源于其他地方时，我就把责任归咎于可怜的老
删除
。所有
delete
显示的是1）您没有对分配有
new
的缓冲区的指针发出
delete
，或者2）您的程序很久以前就损坏了内存，
delete
只是内存损坏的症状。@Cuber Yes Iam@PaulMcKenzie我使用“新”分配内存将节点插入BST期间的关键字。@DarshanKalola-然后检查
new
返回的值。它是否与您发出
delete
时使用的值相同？注意，关键字是value，而不是pointer。您可以让
new
返回一个值，然后通过更改该值将指针弄乱，然后在该指针上发出
new
，认为一切正常。