搜索二叉树的算法实现

搜索二叉树，又叫排序二叉树、二叉查找树。它是一棵空树或者具有以下性质：
1. 每个结点上都有作为搜索依据的关键码，所在结点的关键码互不相同。
2. 左子树上的所有结点小于根结点。
3. 右子树上的所有结点大于跟结点。
4. 左右子树都可以看成搜索二叉树。

上图就是一个简单的搜索二叉树。介绍完搜索二叉树，接下来简要说一下它的实现。用一个结构体保存它的结点信息，然后再去创建它的类。

template<class K>
struct SearchBinaryNode
{
    K _key;
    SearchBinaryNode<K>* _left;
    SearchBinaryNode<K>* _right;

    SearchBinaryNode(const K& x)
        :_key(x)
        , _left(NULL)
        , _right(NULL)
    {}
};

template<class K>
class SearchBninaryTree
{
    typedef SearchBinaryNode<K> Node;
public:
    SearchBninaryTree()
        :_root(NULL)
    {}
    ……
 protected:
    Node* _root;
};

那么接下来进入主题实现搜索二叉树的插入与删除。对于搜索二叉树，我们能够发现，它的中序遍历是按照升序依次遍历完所有节点的。

搜索二叉树的插入

对一个搜索二叉树来说，它的所有结点都满足上面的几条性质，那么当我们插入的时候也要根据性质去构建它。当一定要注意的是，每当我们插入一个数字前，首先要判断在已存在的树中是否已存在该结点。

拿上图所示的搜索二叉树为例，假如我们得到一个二叉树的序列是：5, 3, 4, 1, 7, 8, 2, 6, 0, 9。当前是没有根结点的，这时第一数字插入时就要构建一个根结点。当已经存在根结点了，我们需要判断当前要插入的key和根结点的大小，比根结点的关键码大，那就插入在右边；比它小，即插入在左边。步骤展示如下。

借用一个动画可以更形象展示这种思路。

    bool Insert(const K& key)   
    {
        if (_root == NULL)   //1.当没有结点时，创建一个结点，并赋值给它
        {
            _root = new Node(key);
            return true;
        }

        //搜索该元素是否存在
        Node* parent = NULL;
        Node* cur = _root;
        while (cur)
        {
            if (cur->_key > key)      //当key < 根时，在结点的左边
            {
                parent = cur;
                cur = cur->_left;
            }

            else if (cur->_key < key)   //当key > 根时，在结点的右边
            {
                parent = cur;
                cur = cur->_right;
            }

            else
            {
                return false;
            }

        }

         //2.已存在结点，判断key值与结点的大小
        if (parent->_key > key)
        {
            parent->_left = new Node(key);
            return true;
        }
        else
        {
            parent->_right = new Node(key);
            return true;
        }
    }

当然在这里，也可以用递归去实现插入，思路相同。都先去判断大小，然后通过递归，变成寻找子树的插入，……最后变成创建一个根。

    bool _InsertR(Node*& root, const K& key)
    {
        if (root == NULL)
        {
            root = new Node(key);
            return true;
        }
        if (root->_key > key)
        {
            return _InsertR(root->_left, key);
        }

        if (root->_key < key)
        {
            return _InsertR(root->_right, key);
        }
        return false;
    }

二叉搜索树的删除

在搜索二叉树中删除一个结点，必须将删除结点而断开结点重新链接起来，保证它的性质不会改变。接下来我们分析删除可能存在的情况。

1. 删除叶子结点，只需将它的父亲结点指向它的指针置空，然后释放即可；
2. 如果被删除的结点没有左子树或者右子树，用它的右孩子或者左孩子结点替换它，然后在释放；
3. 如果被删除的结点既有左子树也有右子树，这时我们需要找一个结点来替代它。这个结点就是右子树中序遍历下的第一个结点，接着在处理这个结点的删除问题。

梳理清整个逻辑，下来我们开始实现。

    bool Remove(const K& key)
    {
        Node* parent = NULL;
        Node* cur = _root;
        while (cur)
        {
            if (cur->_key > key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else if (cur->_key < key)
            {
                parent = cur;
                cur = cur->_right;
            }

            else                
            {
                Node* del = cur;
                if (cur->_left == NULL)
                {

                    if (parent == NULL)
                    {
                        _root = cur->_right;
                    }
                    else
                    {
                        if (parent->_right == cur)
                        {
                            parent->_right = cur->_right;
                        }

                        else
                            parent->_left = cur->_right;
                    }
                }
             }
                else if (cur->_right == NULL)
                {
                    if (parent == NULL)
                    {
                        _root = cur->_left;
                    }
                    else
                    {
                        if (parent->_left == cur)
                        {
                            parent->_left = cur->_left;
                        }
                        else
                            parent->_right = cur->_left;

                    }       
                }

                else     //第三种情况，既含左子树又有右子树
                {
                    Node* subRight = cur->_right;
                    Node* subParent = cur;
                    while (subRight->_left)
                    {
                        subRight = subRight->_left;
                    }

                    cur->_key = subRight->_key;
                    del = subRight;

                    if (subParent->_right == subRight)
                        subParent->_right = subRight->_right;
                    else
                        subParent->_left = subRight->_left;
                }
                delete del;
                return true;
            }
        }
        return false;
    }

递归实现删除问题时，思路会更加简单。当左右子树分别为空时，我们只需要把下一个结点直接链接到当前结点即可。

bool _RemoveR(Node*& root, const K& key)
    {
        if (root == NULL) return false;
        if (root->_key > key)
            return _RemoveR(root->_left, key);
        else if (root->_key < key)
            return _RemoveR(root->_right, key);
        else
        {
            Node* del = root;
            if (root->_left == NULL)
                root = root->_right;
            else if (root->_right == NULL)
                root = root->_left;
            else
            {
                Node* subRight = root->_right;
                Node* subParent = root;
                while (subRight->_left)
                {
                    subRight = subRight->_left;
                }

                root->_key = subRight->_key;
                del = subRight;

                if (subParent->_right == subRight)
                    subParent->_right = subRight->_right;
                else
                    subParent->_left = subRight->_left;
            }
            delete del;
            return true;
        }
    }

搜索二叉树的查找

在搜索二叉树上进行查找，是从一个根结点开始，沿着一个分支逐层向下比较判断。可以看作是一个递归的过程。如果当我们已经找到最后一个结点，还没有找到，那就查找失败；如果查找到等于关键码，那就查找成功。接下来分别给出迭代和递归的搜索算法。

    bool Find(const K& key)   //迭代
    {
        Node* cur = _root;
        while (cur)
        {
            if (cur->_key > key)
                cur = cur->_left;
            else if (cur->_key < key)
                cur = cur->_right;
            else return true;
        }
        return false;
    }

    bool _FindR(Node* root, const K& key)   //递归
    {
        if (root==NULL) return false;
        else if (root->_key > key)
            _FindR(root->_left, key);
        else if (root->_key < key)
            _FindR(root->_right, key);

        else
            return root;
    }