刪除二進制搜索樹（BST）中的節點會導致seg錯誤

Question

我在從BST中刪除節點時遇到了麻煩，而且似乎找不到導致seg錯誤的元凶。 我已經測試過BST的所有其他部分，並且運行平穩。 我也嘗試過刪除條件不同的節點，但是結果都是一樣的。

template <typename object>
bool BST<object>::remove(object& data)
{
    if (nodes == 0)
    {
        return false;
    }
    else
    {
        return remove(root_, data);
    }
}



template <typename object>
bool BST<object>::remove(node<object>* current_node_, object& data)
{
    if (current_node_ == NULL)
    {
        return false;
    }

    int relation = compare(data, current_node_->get_data());

    //if you need to keep searching right
    if (relation > 0)
    {
        remove(current_node_->get_right(), data);
    }
    else if (relation < 0)
    {
        remove(current_node_->get_left(), data);
    }
    else
    {
        //LEAF CASE
        if (current_node_->is_leaf())
        {
            //root case
            if (compare(root_->get_data(), data) == 0)
            {
                root_ = NULL;
            }

            else
            {
                if (current_node_->is_right_child())
                {
                    current_node_->get_parent()->set_right(NULL);
                }
                else
                {
                    current_node_->get_parent()->set_left(NULL);
                }
            }

            //release from memory
            delete current_node_;
            nodes--;
        }
        //ONE CHILD CASE
        else if (current_node_->has_one_child())
        {
            //root node
            if (compare(root_->get_data(), data) == 0)
            {
                if (current_node_->get_right() != NULL)
                {
                    current_node_->get_right()->set_parent(NULL);
                    root_ = current_node_->get_right();
                }
                else
                {
                    current_node_->get_left()->set_parent(NULL);
                    root_ = current_node_->get_left();
                }
            }

            //node with right child
            else if(current_node_->get_right() != NULL)
            {
                current_node_->get_right()->set_parent(current_node_->get_parent());
                if (current_node_->is_right_child())
                {
                    current_node_->get_parent()->set_right(current_node_->get_right());
                }
                else
                {
                    current_node_->get_parent()->set_left(current_node_->get_right());
                }
            }
            //node with left child
            else
            {
                current_node_->get_left()->set_parent(current_node_->get_parent());
                if (current_node_->is_right_child())
                {
                    current_node_->get_parent()->set_right(current_node_->get_left());
                }
                else
                {
                    current_node_->get_parent()->set_left(current_node_->get_left());
                }
            }

            //release from memory
            delete current_node_;
            nodes--;
        }
        //TWO CHILDREN CASE
        else
        {
            node<object>* temp_node_ = find_min(current_node_->get_right());
            object* temp_object_ = new object(temp_node_->get_data());

            remove(temp_node_, temp_node_->get_data());
            current_node_->set_data(*temp_object_);
        }
        return true;
    }
    return false;
}

template <typename object>
node<object>* BST<object>::find_min(node<object>* current_node_)
{
    if(current_node_->get_left() != NULL)
    {   
        find_min(current_node_->get_left());
    }
    else 
    {
        return current_node_;
    }
}

Answer 1

寫

current_node_=NULL;

每行之后

delete current_node_;

在刪除功能。 讓我告訴它是否有效。