C++ 二叉搜索树查找并删除[C+；+；]

目前，我正在尝试修复使用递归进行的查找和删除函数。然而，我正在讨论的问题是，当它到达案例二的结尾时，如何确定它是导致案例零还是案例一

    bool findAndRemove(const Type& v)
{
    return findAndRemove(root, nullptr, v);
}

bool findAndRemove(Node<Type> *fr, Node<Type> *parent, const Type& v) const
{
    if (fr == nullptr)
    {
        return true;
    }

    if (v < fr->element)
    {
        return findAndRemove(fr->left, fr, v);
    }
    else if (v > fr->element)
    {
        return findAndRemove(fr->right, fr, v);
    }
    else
    {
        switch (GetChildren(fr))
        {
        case 0:
            if (parent->left == fr)
            {
                parent->left = nullptr;
                delete fr;
            }
            else
            {
                parent->right = nullptr;
                delete fr;
            }
            break;
        case 1:
            if (parent->left == fr)
            {
                if (fr->left != nullptr)
                {
                    parent->left = fr->left;
                    delete fr;
                }
                else
                {
                    parent->left = fr->right;
                }

            }
            else
            {
                if (fr->right != nullptr)
                {
                    parent->right = fr->right;
                    delete fr;
                }
                else
                {
                    parent->right = fr->left;
                }
            }
            break;
        case 2:
        {
            Node<Type> * swap = fr->right;
            while (swap->left != nullptr)
            {
                swap = swap->left;
            }

            Type temp = fr->element; // 30
            temp = swap->element; // 35
            swap->element = fr->element; // 30
            fr->element = temp;

            //temp = swap->element;
            //swap->element = temp;
            //temp = fr->element;
            break;
        }
        }
    }
    return false;
}

以下是我尝试做的简短描述： 案例二（两个子）-使用右子树的最小值交换，这将导致案例零或案例一

    bool findAndRemove(const Type& v)
{
    return findAndRemove(root, nullptr, v);
}

bool findAndRemove(Node<Type> *fr, Node<Type> *parent, const Type& v) const
{
    if (fr == nullptr)
    {
        return true;
    }

    if (v < fr->element)
    {
        return findAndRemove(fr->left, fr, v);
    }
    else if (v > fr->element)
    {
        return findAndRemove(fr->right, fr, v);
    }
    else
    {
        switch (GetChildren(fr))
        {
        case 0:
            if (parent->left == fr)
            {
                parent->left = nullptr;
                delete fr;
            }
            else
            {
                parent->right = nullptr;
                delete fr;
            }
            break;
        case 1:
            if (parent->left == fr)
            {
                if (fr->left != nullptr)
                {
                    parent->left = fr->left;
                    delete fr;
                }
                else
                {
                    parent->left = fr->right;
                }

            }
            else
            {
                if (fr->right != nullptr)
                {
                    parent->right = fr->right;
                    delete fr;
                }
                else
                {
                    parent->right = fr->left;
                }
            }
            break;
        case 2:
        {
            Node<Type> * swap = fr->right;
            while (swap->left != nullptr)
            {
                swap = swap->left;
            }

            Type temp = fr->element; // 30
            temp = swap->element; // 35
            swap->element = fr->element; // 30
            fr->element = temp;

            //temp = swap->element;
            //swap->element = temp;
            //temp = fr->element;
            break;
        }
        }
    }
    return false;
}

bool findAndRemove（常量类型&v）
{
返回find和remove（root、nullptr、v）；
}
bool findAndRemove（节点*fr、节点*父节点、常量类型和v）常量
{
如果（fr==nullptr）
{
返回true；
}
if（velement）
{
返回findAndRemove（fr->left，fr，v）；
}
else if（v>fr->element）
{
返回find和remove（fr->right，fr，v）；
}
其他的
{
开关（GetChildren（fr））
{
案例0：
如果（父->左==fr）
{
父->左=空PTR；
删除fr；
}
其他的
{
父->右=nullptr；
删除fr；
}
打破
案例1：
如果（父->左==fr）
{
如果（fr->left！=nullptr）
{
父->左=右->左；
删除fr；
}
其他的
{
父->左=右->右；
}
}
其他的
{
如果（fr->right！=nullptr）
{
父->右=右->右；
删除fr；
}
其他的
{
父级->右=右->左；
}
}
打破
案例2：
{
节点*swap=fr->右侧；
while（交换->左！=nullptr）
{
交换=交换->左；
}
类型temp=fr->element；//30
temp=swap->element；//35
交换->元素=fr->元素；//30
fr->元件=温度；
//临时=交换->元素；
//交换->元素=温度；
//温度=fr->元件；
打破
}
}
}
返回false；
}

根据：

• 在右子树中找到一个最小值
• 用找到的最小值替换要删除的节点的值。现在，右子树包含一个副本
• 将“删除”应用到右侧子树以删除重复项

在您的代码中，swap指向右侧子树中的最小节点，因此如果在此节点上调用

findAndRemove

函数，您只需将其删除即可

{
    // STEP 1: find a minimum value in the right subtree;
    Node<Type> * swap = fr->right;
    while (swap->left != nullptr)
    {
        swap = swap->left;
    }

    // STEP 2: replace value of the node to be removed with found minimum.
    fr->element = swap->element;

    // STEP 3: apply remove to the right subtree to remove a duplicate.
    // Here you should call 'findAndRemove' on 'swap' node
    break;
}

{
//步骤1：在右子树中找到一个最小值；
节点*swap=fr->右侧；
while（交换->左！=nullptr）
{
交换=交换->左；
}
//步骤2：用找到的最小值替换要删除的节点的值。
fr->element=swap->element；
//步骤3：将remove应用于右子树以删除重复项。
//在这里，您应该在“交换”节点上调用“findAndRemove”
打破
}

“交换”没有剩余子项。如果没有正确的子项，则它有0个子项。它有一个孩子，如果它有一个正确的孩子。但你为什么要在意呢？你不能直接调用

查找并删除它吗？更好的是，在其自身的功能中分离移除部分。旁注：当要求您删除root.com时，您的算法将失败。你能详细解释一下吗？@eziobah前两步已经完成了。只有第三个应该采取。第三个表示应用步骤2后的最小节点（即
交换
节点）成为重复节点。因此，您可以删除此重复节点（即
swap
节点）。好啊因此，只需在此节点上调用函数即可。