二叉查找树的性质

当一棵二叉树满足下面条件的时候就成了二叉查找树：对于树的任意一个节点，左儿子的值比右儿子小(或者反过来也行)。
二叉查找树本质还是二叉树，因此也具有二叉树的性质。

二叉查找树的操作

1. 判断某元素是否在树中：contains

这个操作比较简单，递归查找树根.

//公有函数contains通过调用私有函数contains递归查找。
bool contains(const Object &e) const
{
    return contains(e, root);
}

bool contains(const Object &e, Node *t)
{
    if(t == NULL)
        return false;

    if(e < t->element)
        return contains(e, t->left);
    else if(t->element < e)
        return contains(e, t->right);
    else
        return true;
}

2. 插入一个元素:insert

往一个二叉查找树中插入元素不会改变原树的结构，只需要找到一个合适的位置满足二叉查找树的性质就可以了。

void insert(const Object &e)
{
    insert(e, root);
}
//私有函数操作子树,二叉查找树的插入操作不会改变原树的结构
void insert(const Object &e, Node *&t)
{
    //空子树
    if(t == NULL)
    {
        t = new Node(e,NULL,NULL);
    }
    else
    {
        if(e < t->element)
            insert(e, t->left);
        else if(t->element < e)
            insert(e, t->right);
        else
            ;
    }
}

3. 删除一个元素:remove

删除一个元素必须分情况来讨论。

1. 要删除的节点是叶子。
   如果要删除的节点是一个叶子，那么只需要简单地删除这个节点，并将其父节点的相关指针置为NULL就可以了，具体的做法是直接将这个节点的指针变为NULL，然后释放其存储。
2. 要删除的节点只有一个子树。
   如果要删除的节点只有一个子树，那么只需要让该节点的父节点指向节点的子树，然后释放掉该节点的存储。
3. 要删除的节点有两个子树。
   如果要删除的节点有两个子树，那么需要找出该节点右子树中的最小元素，并将这个最小元素赋给本节点，再将右子树中的该元素删除，此时的删除操作就转化成了1中情况(最小元素必为叶子)。

其中，上述1和2可以合并实现。

void remove(const Object &e)
{
    remove(e, root);
}
void remove(const Object &e, Node *&t)
{
    if(t == NULL)
        return;

    //未找到元素e,于是递归查找
    if(e < t->element)
        remove(e, t->left);
    else if(t->element < e)
        remove(e, t->right);
    //找到元素e
    else if(t->left != NULL && t->right != NULL) //有两个子节点
    {
        t->element = findMin(t->right);
        remove(t->element, t->right);
    }
    else
    {
        Node *old = t;
        t = (t->left != NULL)? t->left : t->right;
        delete old;
    }
}

二叉查找树C++实现

template <typename Object>
class BinarySearchTree
{
    public:
        BinarySearchTree():root(NULL){}
        BinarySearchTree(BinarySearchTree &t)
        {
            root = t;  //浅拷贝
        }
        ~BinarySearchTree()
        {
            makeEmpty();
        }
    
        //深拷贝
        BinarySearchTree & operator =(BinarySearchTree &t)
        {
            if(root == t)
                return;
            if(root != NULL)
                makeEmpty();
            root = clone(root);
        }

        void insert(const Object &e)
        {
            insert(e, root);
        }
        void remove(const Object &e)
        {
            remove(e, root);
        }
        bool contains(const Object &e) const
        {
            return contains(e, root);
        }
        bool isEmpty() const
        {
            return root == NULL;
        }

        const Object & findMin() const
        {
            return findMin(root);
        }
        const Object & findMax() const
        {
            return findMax(root);
        }

        void makeEmpty()
        {
            makeEmpty(root);
        }

        void printTree()
        {
            printTree(root);
            std::cout<<"--------------"<<std::endl;
        }
    private:
        struct Node
        {

            Object element;
            Node *left;
            Node *right;
            Node(const Object &ele, Node *l, Node *r):element(ele),left(l),right(r){}
        };

        Node *root;
        
        //私有函数操作子树,二叉查找树的插入操作不会改变原树的结构
        void insert(const Object &e, Node *&t)
        {
            //空子树
            if(t == NULL)
            {
                t = new Node(e,NULL,NULL);
            }
            else
            {
                if(e < t->element)
                    insert(e, t->left);
                else if(t->element < e)
                    insert(e, t->right);
                else
                    ;
            }
        }

        void remove(const Object &e, Node *&t)
        {
            if(t == NULL)
                return;

            //未找到元素e,于是递归查找
            if(e < t->element)
                remove(e, t->left);
            else if(t->element < e)
                remove(e, t->right);
            //找到元素e
            else if(t->left != NULL && t->right != NULL) //有两个子节点
            {
                t->element = findMin(t->right);
                remove(t->element, t->right);
            }
            else
            {
                Node *old = t;
                t = (t->left != NULL)? t->left : t->right;
                delete old;
            }
            

        }

        bool contains(const Object &e, Node *t)
        {
            if(t == NULL)
                return false;

            if(e < t->element)
                return contains(e, t->left);
            else if(t->element < e)
                return contains(e, t->right);
            else
                return true;

        }

        const Object & findMin(Node *t) const
        {
            while(t->left != NULL)
            {
                t = t->left;       //查找最左边的元素
            }

            return t->element;
        }
    
        const Object & findMax(Node *t) const
        {
            while(t->right != NULL)
            {
                t = t->right;     //查找最右边的元素
            }

            return t->element;
        }

        void makeEmpty(Node * &t)
        {
            if(t != NULL)
            {
                makeEmpty(t->left);
                makeEmpty(t->right);
                delete t;
            }
             t = NULL;
        }

        Node * clone(Node *t)
        {
            if(t == NULL)
                return;
            
            return new Node(t->element, t->left, t->right); 

        }

        void printTree(const Node *t)
        {
            if(t == NULL)
                return;
            std::cout<<t->element<<std::endl;
            if(t->left != NULL)
                printTree(t->left);
            if(t->right != NULL)
                printTree(t->right);
        }
};