二叉搜索树

由于普通链表的查找，删除的时间复杂度为o(n)，插入的时间复杂度为o(1)，现介绍一种查找，删除，插入的时间复杂度均在o(logn)~o(n)之间的数据结构，这就是二叉搜索树。

二叉搜索树的规则：

1.每一个父节点都有0~2个子结点，分别为左孩子节点，右孩子节点。

2.左孩子节点的值小于父节点的值，父节点的值小于右孩子节点的值。

 

根据第一条规则，我们可以将一个二叉搜索树分解为两个子二叉搜索树加一个根节点。从第二条规则我们可以知道，左子树上的任意节点值都小于根节点值，而右子树上的任意节点值都大于根节点值。如图所示，(a)为二叉搜索树，而(b)不是。因为(b)中左子二叉树上的值为7的节点大于根节点6。 

 

 

 

 

 

 

 

 

 

具体的实现代码为：

template<typename T>
struct bs_tree_node
{
    bs_tree_node(const T& _element, bs_tree_node *_left, bs_tree_node *_right)
        : element(_element)
        , left(_left)
        , right(_right)
    {
    }
    T    element;
    bs_tree_node    *left;
    bs_tree_node    *right;
};

template<typename T>
class bs_tree
{
    typedef bs_tree_node<T> bs_tree_node;
public:
    bs_tree() { m_root = NULL; }
    bs_tree(const bs_tree& rhs)
        : m_root(rhs.m_root)
    {}
    const bs_tree& operator=(const bs_tree& rhs)
    {
        if(this!=&rhs)
        {
            clear();
            m_root = clone(rhs.m_root);
        }
    }

    ~bs_tree() 
    {
        clear(m_root);
    }

public:
    const T& find_min() const
    {
        bs_tree_node* node = find_min(m_root);
        if(node)
        {
            return node->element;
        }
        throw std::runtime_error("查找二叉树无任何节点");
    }

    const T& find_max() const
    {
        bs_tree_node* node = find_max(m_root);
        if(node)
        {
            return node->element;
        }
        throw std::runtime_error("查找二叉树无任何节点");
    }

    bool contains(const T& x) const
    {
        return contains(x,m_root);
    }

    bool is_empty() const
    {
        return m_root==NULL;
    }

    void clear()
    {
        clear(m_root);
    }

    void insert(const T& x)
    {
        insert(x,m_root);
    }

    void remove(const T& x)
    {
        remove(x,m_root);
    }

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

    template<typename Functor>
    void foreach(Functor& functor)
    {
        foreach(m_root,functor);
    }

private:
    bs_tree_node* find_min(bs_tree_node* t) const
    {
        if( t==NULL )
        {
            return NULL;
        }
        while(t->left!=NULL)
        {
            t = t->left;
        }
        return t;
    }

    bs_tree_node* find_max(bs_tree_node* t) const
    {
        if( t==NULL )
        {
            return NULL;
        }
        while(t->right!=NULL)
        {
            t = t->right;
        }
        return t;
    }

    bool contains(const T& x, bs_tree_node* t) const
    {
        if( t == NULL )
        {
            return false;
        }
        else if( x<t->element )
        {
            return contains( x, t->left );
        }
        else if( x>t->element )
        {
            return contains(x, t->right);
        }
        else
        {
            return true;
        }
    }

    void insert(const T& x, bs_tree_node*& t)
    {
        if( t == NULL )
        {
            t = new bs_tree_node(x,NULL,NULL);
        }
        else if( x<t->element)
        {
            insert(x,t->left);
        }
        else if( x>t->element )
        {
            insert(x,t->right);
        }
        else
        {}
    }

    void remove(const T& x, bs_tree_node*& t)
    {
        if( t== NULL )
        {
            return;
        }
        else if( x < t->element)
        {
            remove(x,t->left);
        }
        else if( x > t->element )
        {
            remove(x,t->right);
        }
        else if( t->left != NULL && t->right != NULL)
        {
            t->element = find_min( t->right )->element;
            remove( t->element, t->right);
        }
        else
        {
            bs_tree_node *old_node = t;
            t = (t->left != NULL)?t->left:t->right;
            delete old_node;
        }
    }

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

    template<typename Functor>
    void foreach(bs_tree_node* t, Functor& functor)
    {
        if(t!=NULL)
        {
            functor(t);
            foreach(t->left, functor);
            foreach(t->right, functor);
        }
    }

private:
    bs_tree_node    *m_root;
};

由于二叉搜索树的查找，删除，添加在理想的情况下都与二分搜索算法类似，可以知道它的最优时间复杂度为o(logn)，然而像极端情况下，如所有节点都是左孩子或者所有节点都是右孩子，则二叉搜索树退化为普通有序链表，各项操作的时间复杂度为o(n)。二叉搜索树的具体形状则与插入顺序有关。比如:

bs_tree<int> tree;
for(int i = 0; i<1000*1000*1000; ++i)
{
    tree.insert(i);
}

 

像上述代码则产生了一个所有节点都为左孩子的二叉搜索树，性能与普通有序链表一致。由此可知经过频繁的插入删除操作，二叉搜索树的性能可能下降或者上升。

除了上述缺点之外，实际上上述代码无法运行，因为插入操作的具体实现是一个递归调用过程，极端情况下它需要遍历每一个元素才能确定插入位置，而上述插入操作会导致函数栈溢出。