二叉搜索树

二叉搜索树
【概念】
二叉搜索树：又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树
1、若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
2、若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
3、它的左右子树也分别为二叉搜索树
例：此树就是一颗二叉搜索树。

【操作】

—搜索：若根节点不为空
如果根节点的key==查找key，返回true
如果根节点的key<查找key,在其左子树中查找
如果根节点的key>查找key,在其右子树中查找
否则，返回false

—插入：
在向二叉搜索树中插入新元素时，必须先检测这个元素是否在树中已经存在。如果搜索成功，说明该元素已经存在，则不进行插入；否则将新元素加入到搜索停止的地方。

—删除：
首先查找元素是否在二叉搜索树中，如果不存在，则返回；否则要删除的结点可能分下面四种情况：

1、要删除的结点无孩子结点；
2、要删除的结点只有左孩子结点；
3、要删除的结点只有右孩子结点；
4、要删除的结点有左、右孩子结点；

对于上述情况，相应的删除方法如下：
a、直接删除该结点
b、删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子点；
c、删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子点；
d、在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值补 到被删除节点中，在来处理该结点的删除问题

1–>a :
2–b :
3–c :
4–d :

源代码：

template<class T>struct BinarySearchTreeNode{    BinarySearchTreeNode<T>*_pleft;    BinarySearchTreeNode<T>*_pright;    T _key;    BinarySearchTreeNode(const T&key)        :_pleft(NULL)        , _pright(NULL)        , _key(key)    {}};template<class T>class BinarySearchTree{    typedef BinarySearchTreeNode<T> Node;public:    BinarySearchTree()        :_proot(NULL)    {}    BinarySearchTree(T*a, size_t size)    {        _proot = NULL;        for (int i = 0; i < size; ++i)        {            Insert(a[i]);        }    }    bool Insert(const T&data)    {        if (_proot == NULL)        {            _proot = new Node(data);            return true;        }        Node*pCur = _proot;        Node*parent = NULL;        while (pCur)        {            parent = pCur;            if (pCur->_key < data)                pCur = pCur->_pright;            else if (pCur->_key>data)                pCur = pCur->_pleft;            else                return false;        }        if (parent->_key < data)            parent->_pright = new Node(data);        else if(parent->_key > data)            parent->_pleft = new Node(data);        return true;    }    Node* Find(const T&data)    {        Node*pCur = _proot;        while (pCur)        {            if (data == pCur->_key)                return pCur;            if (data < pCur->_key)                pCur = pCur->_pleft;            else                pCur = pCur->_pright;        }        return NULL;    }    bool Remove(const T&data)    {        Node*pCur = _proot;        Node*parent = NULL;        while (pCur)        {            if (pCur->_key < data)            {                parent = pCur;                pCur = pCur->_pright;            }            else if (pCur->_key>data)            {                parent = pCur;                pCur = pCur->_pleft;            }            else            {                if (pCur->_pleft == NULL)//当前节点左孩子为空，将右孩子直接复制                {                    if (parent == NULL)//判断当前节点是不是根节点                    {                        _proot = pCur->_pright;                    }                    else//待删除结点为右孩子                    {                        if (parent->_pleft == pCur)                            parent->_pleft = pCur->_pright;                        else                            parent->_pright = pCur->_pright;                    }                    delete pCur;                }                else if (parent->_pright == NULL)//待删除结点为左孩子                {                    if (parent == NULL)                    {                        _proot = pCur->_pright;                    }                    else                    {                        if (parent->_pleft == pCur)                            parent->_pleft = pCur->_pleft;                        else                            parent->_pright = pCur->_pleft;                    }                    delete pCur;                }                else//左右子树都不为空，将右子树中最左节点交换                {                    Node*tmp = pCur->_pright;                    Node*prev = pCur;                    while (tmp->_pleft)                    {                        prev = tmp;                        tmp = tmp->_pleft;                    }                    swap(tmp->_key, pCur->_key);                    if (tmp==prev->_pright)                    {                        pCur->_pright = tmp->_pright;                    }                    else if (prev->_pleft==tmp)                    {                        prev->_pleft = tmp->_pright;                    }                    delete tmp;                }                return true;            }        }        return false;    }    BinarySearchTree<T>& operator=(BinarySearchTree<T>&tree)    {        if (this != &tree)        {            BinarySearchTree<T>tmp(tree);            swap(_proot, tmp._proot);        }        return *this;    }    BinarySearchTree(const BinarySearchTree<T>&tree)        :_proot(NULL)    {        if (tree._proot == NULL)            return;        queue<Node*>q;        q.push(tree._proot);        while (!q.empty())        {            Node*pCur = q.front();            Insert(pCur->_key);            q.pop();            if (pCur->_pleft)            {                q.push(pCur->_pleft);            }            if (pCur->_pright)            {                q.push(pCur->_pright);            }        }    }    ~BinarySearchTree()    {        _Destory(_proot);    }    Node*_Find_Min(const Node&proot)    {        assert(proot);        while (proot->_pleft)        {               proot = proot->_pleft;        }        return proot;    }    Node*_Find_MAX(const Node&proot)    {        assert(proot);        while (proot->_pright)        {            proot = proot->_pright;        }        return proot;    }private:    void _Destory(Node*proot)    {        if (proot == NULL)            return;        _Destory(proot->_pleft);        _Destory(proot->_pright);        delete proot;    }private:    BinarySearchTreeNode<T>*_proot;};