Templates 模板BST的删除功能中存在分段错误

所以我制作了一个模板BST来保存其他对象作为值。除了deleteNode函数外，所有功能都正常工作。在main方法中调用deleteNode函数时，我遇到了一个分段错误。我不太明白如何为BSTs编写删除函数，因此很难找到错误。非常感谢您的帮助

这是我的BST.h文件：

#ifndef BSTTEMPLATE_H
#define BSTTEMPLATE_H
#include <iostream>
#include<stdio.h>
#include<stdlib.h>

using namespace std;

template <class T>

class BSTTemplate{
    struct node{
        T value;
        struct node* right;
        struct node* left;
    };

public:

    BSTTemplate(){
    this->root = NULL;
    this->treeSize = 0;
  }

    ~BSTTemplate(){
    deleteTree(this->root);
  }

    void add(T val){
    add(&(this->root), val);
  }

    void printPreOrder(){
        printPreOrder(this->root);
        std::cout << std::endl;
  }

    void printInOrder(){
    printInOrder(this->root);
    std::cout << std::endl;
  }

    void printPostOrder(){
        printPostOrder(this->root);
        std::cout << std::endl;
  }

    int size(){
    return this->treeSize;
  }

    bool lookup(T val){
    return lookup(this->root, val);
  }

    void deleteNode(T val){
        deleteNode(this->root, val);
    }


private:
    struct node* root;
    int treeSize;

    void deleteNode(struct node *&node, T val){
        if (val <= node->value){
            deleteNode(node->left, val);
        }
        else if (val >= node->value){
            deleteNode(node->right, val);
        }
        else{
            makeDeletion(node);
        }
    } 

    void makeDeletion(struct node *&node){
        struct node *tempNode = NULL;
        if(node == NULL){
            cout << "Cannot delete empty node" << endl;
        } 
        else if (node->right == NULL){
            tempNode = node;
            node = node->left;
            delete tempNode;
        }
        else if(node->left == NULL){
            tempNode = node;
            node = node->right;
            delete tempNode;
        }
        else{
            tempNode = node->right;
            while(tempNode->left){
                tempNode = tempNode->left;
            }
            tempNode->left = node->left;
            tempNode = node;
            node = node->right;
            delete tempNode;
        }
    }

    void add(struct node** node, T val){
    if(*node == NULL)   {
        struct node* tmp = new struct node;
        tmp->value = val;
        tmp->left=NULL;
        tmp->right = NULL;
        *node = tmp;

        this->treeSize++;
    }else{
        if(val >= (*node)->value){
            add(&(*node)->right, val);
        }else{
            add(&(*node)->left, val);
        }
    }
  }

    bool lookup(struct node* node, T val){
    if(node == NULL){
        return false;
    }else{
        if(val == node->value){
            return true;
        }

        if(val > node->value){
            return lookup(node->right, val);
        }else{
            return lookup(node->left, val);
        }
    }
  }

    void printPreOrder(struct node* node){
    if(node != NULL)    {
        std::cout << node->value << ", ";
        printInOrder(node->left);
        printInOrder(node->right);
    }
  }

    void printInOrder(struct node* node){
    if(node != NULL){
        printInOrder(node->left);
        std::cout << node->value << "";
        printInOrder(node->right);
    }
  }

    void printPostOrder(struct node* node){
    if(node != NULL){
        printInOrder(node->left);
        printInOrder(node->right);
        std::cout << node->value << "";
    }
  }
    void deleteTree(struct node* node){
    if(node != NULL){
        deleteTree(node->left);
        deleteTree(node->right);
        delete node;
    }
  }
};


#endif

\ifndef bstu H
#定义模板
#包括
#包括
#包括
使用名称空间std；
模板
类模板{
结构节点{
T值；
结构节点*右；
结构节点*左；
};
公众：
BSTemplate（）{
此->根=空；
此->树大小=0；
}
~bstmplate（）{
删除树（此->根）；
}
无效添加（T val）{
添加（&（此->根），val）；
}
无效打印预订单（）{
printPreOrder（此->根目录）；
std：：cout根）；
std：：cout根）；
标准：：cout-treeSize；
}
布尔查找（T val）{
返回查找（此->根，val）；
}
void deleteNode（T val）{
删除节点（此->根，val）；
}
私人：
结构节点*根；
内特树；
void deleteNode（结构节点*&节点，T val）{
if（val值）{
删除节点（节点->左侧，val）；
}
else if（val>=节点->值）{
删除节点（节点->右侧，val）；
}
否则{
makeDeletion（节点）；
}
} 
void makeDeletion（结构节点*&节点）{
结构节点*tempNode=NULL；
if（node==NULL）{
不能离开；
删除临时节点；
}
else if（节点->左==NULL）{
tempNode=节点；
节点=节点->右侧；
删除临时节点；
}
否则{
tempNode=node->right；
while（tempNode->left）{
tempNode=tempNode->left；
}
tempNode->left=节点->左侧；
tempNode=节点；
节点=节点->右侧；
删除临时节点；
}
}
void add（结构节点**节点，T val）{
如果（*节点==NULL）{
结构节点*tmp=新建结构节点；
tmp->value=val；
tmp->left=NULL；
tmp->right=NULL；
*node=tmp；
这->树化++；
}否则{
如果（val>=（*节点）->值）{
添加（&（*节点）->右侧，val）；
}否则{
添加（&（*节点）->左侧，val）；
}
}
}
布尔查找（结构节点*节点，T值）{
if（node==NULL）{
返回false；
}否则{
if（val==节点->值）{
返回true；
}
如果（val>节点->值）{
返回查找（节点->右侧，val）；
}否则{
返回查找（节点->左，val）；
}
}
}
无效打印预订单（结构节点*节点）{
如果（节点！=NULL）{
std：：cout值（左）；
打印顺序（节点->右侧）；
}
}
无效打印顺序（结构节点*节点）{
如果（节点！=NULL）{
打印顺序（节点->左侧）；
std：：cout value right）；
}
}
作废printPostOrder（结构节点*节点）{
如果（节点！=NULL）{
打印顺序（节点->左侧）；
打印顺序（节点->右侧）；
std：：cout值（左）；
删除树（节点->右侧）；
删除节点；
}
}
};
#恩迪夫