C++ 从二叉搜索树中删除只有一个子节点的节点

这是从二进制搜索树中删除节点的代码： 我的问题是：为什么我们通过引用将节点指针传递给

DelSingle

函数，而通过复制将节点指针传递给

deldouble

函数

template <class T>
bool BST<T>::DeleteNode(T& val)
{
BSTNode<T> * node = root, *prev = NULL;

if (IsEmpty() == true)
    return false;

while (node != NULL)
{
    if (node->val == val)
        break;
    prev = node;
    if (val < node->val)
        node = node->left;
    else
        node = node->right;
}

if (node == NULL)
    return false;

if (node->left == NULL || node->right == NULL)
{
    if (node == root)
        DelSingle(root);
    else if(node == prev->left)
        DelSingle(prev->left);
    else
        DelSingle(prev->right);
}
else
    DelDoubleByCopying(node);

return true;
}

template <class T>
void BST<T>::DelSingle(BSTNode<T>*& ptr)
{
BSTNode<T>* delNode = ptr;

if(delNode->left == NULL) // node does not have a left child
    ptr = delNode->right;
else if(delNode->right == NULL) // node does not have a right child
    ptr = delNode->left;
delete delNode;
}

template <class T>
void BST<T>::DelDoubleByCopying(BSTNode<T>* node)
{
BSTNode<T> *prev, *rep;

rep = node->left;  //Find the largest child in the left subtree
prev = node;
while (rep->right != NULL)
{
    prev = rep;
    rep = rep->right;
}
node->val = rep->val;
if (prev == node)
    prev->left = rep->left;
else
    prev->right = rep->left;
delete rep;
}

模板
布尔BST:：删除节点（T&val）
{
BSTNode*node=root，*prev=NULL；
如果（IsEmpty（）==true）
返回false；
while（节点！=NULL）
{
如果（节点->val==val）
打破
prev=节点；
if（valval）
节点=节点->左；
其他的
节点=节点->右侧；
}
if（node==NULL）
返回false；
如果（节点->左==NULL | |节点->右==NULL）
{
如果（节点==根）
单根；
else if（节点==prev->left）
DelSingle（上一个->左）；
其他的
DelSingle（上一个->右）；
}
其他的
DelDoubleByCopying（节点）；
返回true；
}
模板
void BST:：DelSingle（BSTNode*&ptr）
{
BSTNode*delNode=ptr；
if（delNode->left==NULL）//节点没有左子节点
ptr=delNode->右侧；
else if（delNode->right==NULL）//节点没有正确的子节点
ptr=delNode->left；
删除delNode；
}
模板
void BST:：DelDoubleByCopy（BSTNode*节点）
{
BSTNode*prev，*rep；
rep=node->left；//在左子树中查找最大的子树
prev=节点；
while（rep->right！=NULL）
{
prev=rep；
rep=rep->right；
}
节点->值=代表->值；
if（prev==节点）
上一个->左=代表->左；
其他的
上一个->右=代表->左；
删除代表；
}

这是一类二叉搜索树节点：

template <class T>
class BSTNode
{ 
public:
BSTNode(T& val, BSTNode* left, BSTNode* right);
~BSTNode();
T GetVal();
BSTNode* GetLeft();
BSTNode* GetRight();

private:
T val;
BSTNode* left;
BSTNode* right;
int depth, height;
friend class BST<T>;
};

模板
类节点
{ 
公众：
BSTNode（T&val，BSTNode*左，BSTNode*右）；
~BSTNode（）；
T GetVal（）；
BSTNode*GetLeft（）；
BSTNode*GetRight（）；
私人：
T值；
节点*左；
节点*对；
int深度、高度；
朋友班；
};

• DelSingle（）

给定以下结构

        parent
    ptr1    ptr2
child1

假设我们正在删除

ptr1

：

基本上，

DelSingle（）

所做的就是用

ptr1

交换

child1

，然后骑上

child1

（

child1

不是

ptr1

曾经的样子）

ptr

是通过引用传递的，因为您正在实际更改指针，父对象的左子对象不是

child1

• DelDoubleByCopying（）

您不需要通过引用传递节点，因为

node

不会更改，更改的是

node->left

（或

node->right

）