Blue is white,dark is not blue(二叉搜索树)

onething

#include <iostream>
#include <deque>
class BinarySearchTree
{
private:
    struct Node
    {
        int data = 0;
        Node *left = nullptr;
        Node *right = nullptr;
        Node(int data):data(data) {}
    };
    Node * root = nullptr;

    bool internalPush(Node *& root,int value)
    {
        if(root == nullptr)
        {
            root = new Node(value);
            return true;
        }
        else if(root->data == value) // 如果已经有该元素 则插入失败
        {
            return false;
        }
        else if(root->data < value)
        {
            return internalPush(root->right,value);
        }
        else
        {
            return internalPush(root->left,value);
        }


    }
    //递归删除 需要用引用作参数 //cursor为子数根节点 value为要删除的值 parent子树的父节点 isLeftChild 为是否是左子树
    bool internalRemove(Node *& cursor,int value,Node *& parent,bool isLeftChild)
    {
        if(cursor == nullptr) //没有找到 则删除失败
        {
            return false;
        }
        else if(cursor->data < value) //要删除的数字在右子树
        {
            return internalRemove(cursor->right,value,cursor,false);
        }
        else if(cursor->data > value)
        {
            return internalRemove(cursor->left,value,cursor,true);
        }
        else
        {
            //左右孩子都为空 直接删除该子树
            if(cursor->left == nullptr && cursor->right == nullptr)
            {
                delete cursor;
                cursor = nullptr;
                return true;
            }
            else if(cursor->left != nullptr && cursor->right == nullptr)//要删除的节点有左子树
            {
                if(parent == cursor) //根节点情况
                {
                    Node * temp = root; //暂存根结点指针
                    root = root->left; //将根结点重新赋值
                    delete temp;//删除原来的
                    return true;
                }
                else
                {
                    Node * temp = cursor; //暂存结点指针
                    if(isLeftChild)
                    {
                        parent->left = cursor->left;// 将父亲节点的左指针指向要删除节点的左孩子
                        //由于是引用传递 上面等于 cursor = cursor->left 所以需要暂存cursor
                    }
                    else
                    {
                        parent->right = cursor->left;
                    }
                    delete temp;
                    return true;
                }
            }
            else if(cursor->right != nullptr && cursor->left == nullptr)
            {

                if(parent == cursor)
                {
                    Node * temp = root;
                    root = root->right;
                    delete temp;
                    return true;
                }
                else
                {
                    Node * temp = cursor;
                    if(isLeftChild)
                    {
                        parent->left = cursor->right;
                    }
                    else
                    {
                        parent->right = cursor->right;
                    }

                    delete temp;
                    return true;
                }
            }
            else
            {
                int miniValue = findMin(cursor->right);
                cursor->data = miniValue;//不删除当前指针 将最小的值给他 然后删除右子树中最小的
                return internalRemove(cursor->right,miniValue,cursor,false);
            }
        }
    }

public:
    BinarySearchTree() = default;

    bool push(int value)
    {
        return internalPush(root,value);
    }

    bool remove(int value)
    {
        return internalRemove(root,value,root,false);
    }

    int findMin(Node * node)
    {
        if(node == nullptr) //如果节点为空 抛出异常
        {
            throw;
        }
        Node * preNode = nullptr;
        while(node != nullptr) //直到空节点 说明他的上个节点就是最小值
        {
            preNode = node;
            node = node->left;
        }
        return preNode->data;
    }

    bool contains(int value)
    {
        Node * cursor = root;
        while(cursor != nullptr)
        {
            if(cursor->data == value)
            {
                return true;
            }
            else if(cursor->data > value)
            {
                cursor = cursor->left;
            }
            else
            {
                cursor = cursor->right;
            }

        }
        return false;
    }

    //层序遍历打印
    void floorTraversalPrint()
    {
        if(root != nullptr)
        {
            std::deque<Node *> q;
            q.push_back(root);

            while(!q.empty())
            {
                Node *  temp = q.front();
                std::cout << temp->data << std::ends;
                if(temp->left != nullptr)
                {
                    q.push_back(temp->left);
                }
                if(temp->right != nullptr)
                {
                    q.push_back(temp->right);
                }
                q.pop_front();
            }

        }
    }

};


int main(int args,char *argv[])
{
    BinarySearchTree tree;
    tree.push(28);


    tree.floorTraversalPrint();
    return 0;
}
这里插入代码片