二叉查找树（BST）的实现（C++）

  1//二叉搜索树的实现，其原理参见《算法导论第二版》第151页。
  2
  3#ifndef BST_H
  4#define BST_H
  5
  6#include <iostream>
  7#include <stdexcept>
  8
  9namespace NTCI
 10{
 11    template<typename Type>
 12    class BST
 13    {
 14    public:
 15        struct Node
 16        {
 17            Type item;
 18            Node* left;
 19            Node* right;
 20            Node* parent;
 21        };
 22        typedef Node* Link;
 23
 24    public:
 25        BST(Link r = 0) : root(r) {}
 26        template<typename InputIterator>
 27        BST(InputIterator start, InputIterator end) : root(0)
 28        {
 29            for (InputIterator i = start; i != end; ++i)
 30                Insert(*i);
 31        }
 32
 33        virtual ~BST()
 34        {
 35            Clear();
 36        }
 37        void Insert(Type item)
 38        {
 39            Link n = new Node();
 40            n->item = item;
 41            InsertBST(root, n);
 42        }
 43
 44        Link Remove(Link link)
 45        {
 46            // 删除空节点时抛出参数无效的异常。
 47            if (link == 0)
 48                throw std::invalid_argument("待删除的结点为空");
 49
 50            // 先确定将要被删除的结点。如果结点只有一个或零个子结点，则原元素将被删除，
 51            // 否侧其后继结点将被删除。
 52            Link removed;
 53            if (link->left == 0 || link->right == 0)
 54                removed = link;
 55            else
 56                removed = Successor(link);
 57
 58            // 待删除的元素至多只有一个子结点。
 59            Link child = 0;
 60            if (link->left != 0)
 61                child = removed->left;
 62            else
 63                child = removed->right;
 64
 65            // 先设置子结点的新的父节点。
 66            if (child != 0)
 67                child->parent = removed->parent;
 68
 69            // 如果待删除的结点为根节点，直接将根结点设置为子结点，
 70            if (removed->parent == 0)
 71                root = child;
 72            // 否则将待删除结点的父节点的子结点指向待删除结点的子结点。
 73            else if (removed == removed->parent->left)
 74                removed->parent->left = child;
 75            else
 76                removed->parent->right = child;
 77
 78            // 如果原结点和被删除的结点不同，则说明原结点具有两个子结点，此时需要将
 79            // 被删除结点的值复制到原结点。
 80            if (link != removed)
 81                link->item = removed->item;
 82
 83            return removed;
 84        }
 85
 86        Link Remove(Type item)
 87        {
 88            Link link = Search(item);
 89            return Remove(link);
 90        }
 91
 92        Link Search(Type item)
 93        {
 94            return SearchBST(root, item);
 95        }
 96
 97        int Maximum()
 98        {
 99            Link max = MaximumBST(root);
            if (max == 0)
                throw std::out_of_range("二叉搜索树为空");
            return max->item;
        }

        int Minimun()
        {
            Link min = MinimunBST(root);
            if (min == 0)
                throw std::out_of_range("二叉搜索树为空");
            return min->item;
        }

        void InorderWalk(std::ostream& out)
        {
            InorderWalkBST(root, out);
        }

        Link Successor(Link link)
        {
            // 如果右子结点不为空，则返回右子树的最小结点，
            if (link->right != 0)
                return MinimunBST(link->right);

            // 否则后继元素是一个祖先结点，该结点的左子结点也是祖先结点。
            Link p = link->parent;
            while (p != 0 && link == p->right)
            {
                link = p;
                p = link->parent;
            }

            return p;
        }

        Link Predecessor(Link link)
        {
            if (link->left != 0)
                return MaximumBST(link->left);

            Link p = link->parent;
            while (p != 0 && link == p->left)
            {
                link = p;
                p = link->parent;
            }

            return p;
        }

        int Heigth()
        {
            return HeightBST(root);
        }

        int Length()
        {
            return LengthBST(root);
        }

        void Clear()
        {
            ClearBST(root);
        }

        void InsertBST(Link& root, Link n)
        {
            if (root == 0)
            {
                root = n;
                return;
            }

            if (n->item < root->item)
            {
                if (root->left == 0)
                {
                    n->parent = root;
                    root ->left = n;
                }
                else
                    InsertBST(root->left, n);
            }
            else
            {
                if (root->right == 0)
                {
                    n->parent = root;
                    root->right = n;
                }
                else
                    InsertBST(root->right, n);
            }

        }
    private:
        Link SearchBST(Link root, Type item)
        {
            if (root == 0 || root->item == item)
                return root;
            if (root->item > item)
                return SearchBST(root->left, item);
            else
                return SearchBST(root->right, item);
        }

        void InorderWalkBST(Link root, std::ostream& out)
        {
            if (root == 0)
                return;

            InorderWalkBST(root->left, out);
            out << root->item << " ";
            InorderWalkBST(root->right, out);
        }

        Link MaximumBST(Link link)
        {
            while (link->right != 0)
                link = link->right;
            return link;
        }

        Link MinimunBST(Link link)
        {
            while (link->left != 0)
                link = link->left;
            return link;
        }

        int HeightBST(Link root)
        {
            if (root == 0)
                return 0;

            int lh, rh;
            lh = HeightBST(root->left);
            rh = HeightBST(root->right);
            return std::max(lh, rh) + 1;
        }


        int LengthBST(Link root)
        {
            if (root == 0)
                return 0;
            return LengthBST(root->left) + LengthBST(root->right) + 1;
        }

        void ClearBST(Link& root)
        {
            if (root == 0)
                return;
            ClearBST(root->left);
            ClearBST(root->right);
            delete root;

            root = 0;
        }

    private:
        Link root;
    };
}

#endif // BST_H

 

 1#include <iostream>
 2#include <cassert>
 3#include <stdexcept>
 4#include "BST.h"
 5
 6using namespace std;
 7using namespace NTCI;
 8
 9int main()
{
    try
    {
        int array[] = {5, 4, 7, 2, 6, 8};
        BST<int> bst(array, array + 6);

        cout << "排序后：";
        bst.InorderWalk(cout);
        cout << endl;

        BST<int>::Link link = bst.Search(5);
        assert(bst.Successor(link)->item == 6);
        assert(bst.Predecessor(link)->item == 4);
        cout << "二叉树高度：" << bst.Heigth() << endl;
        cout << "最大值：" << bst.Maximum() << endl;
        cout << "最小值：" << bst.Minimun() << endl;

        bst.Remove(9);

        link = bst.Search(7);
        assert(link->item == 7);

        link = bst.Remove(link);
        delete link;
        assert(bst.Length() == 5);
        cout << "删除元素7后：";
        bst.InorderWalk(cout);
        cout << endl;

        bst.Clear();
        assert(bst.Length() == 0);
    }
    catch (exception& e)
    {
        cout << "发生异常：" << e.what() << endl;
    }

    return 0;
}

 

要实现随机构造的二叉查找树很容易，先调用标准库的random_shuffle函数对数组进行随机重排，然后再构造二叉搜索树就OK了~

欢迎大家就程序正确性以及代码风格等方面提出建议~