伸展树

伸展树结合了二叉搜索树BST及二叉平衡树AVL的旋转特点，在每一次访问到某节点时都通过旋转将该节点往上推一位，由于没有保存高度信息因为空间复杂度稍优于二叉平衡树。伸展树的插入，删除，搜索的平均时间复杂度均为o(logn)，极端情况下为o(n)。伸展树适用于关注用户习惯性行为，用户经常使用的节点将靠近根节点，而用户不经常使用的将远离根节点。

具体实现代码为：

与BST树实现代码一样，如果伸展树遇到不平衡的情况下，代码中的递归调用将会溢出。

template<typename T>
struct splay_tree_node
{
    splay_tree_node(const T& _element, splay_tree_node *_left = NULL, splay_tree_node *_right = NULL, bool _isdeleted = false)
        : element(_element)
        , left(_left)
        , right(_right)
        , isdeleted(_isdeleted)
    {
    }
    T    element;
    splay_tree_node    *left;
    splay_tree_node    *right;
    bool isdeleted;
};

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

    ~splay_tree() 
    {
        clear(m_root);
    }

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

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

    // 判断树上是否包含该值
    bool contains(const T& x)
    {
        bool brotate = false;
        return contains(x,m_root,brotate);
    }

    // 判断树是否为空
    bool is_empty() const
    {
        return m_root==NULL;
    }

    // 清空树
    void clear()
    {
        clear(m_root);
    }

    // 插入值为x的节点
    void insert(const T& x)
    {
        insert(x,m_root);
    }

    // 移除值为x的节点
    void remove(const T& x)
    {
        remove(x,m_root);
    }

    // 对所有节点执行某项动作
    template<typename Functor>
    void foreach(Functor& functor)
    {
        foreach(m_root,functor);
    }

private:
    // 树最小节点
    tree_node* min(tree_node* t) const
    {
        if( t==NULL )
        {
            return NULL;
        }
        while(t->left!=NULL)
        {
            t = t->left;
        }
        return t;
    }

    // 树最大节点
    tree_node* max(tree_node* t) const
    {
        if( t==NULL )
        {
            return NULL;
        }
        while(t->right!=NULL)
        {
            t = t->right;
        }
        return t;
    }

    // 判断树是否存在该节点
    bool contains(const T& x, tree_node*& t, bool& brotate)
    {
        if( t == NULL )
        {
            return false;
        }
        else if( x<t->element )
        {
            if(contains( x, t->left, brotate ))
            {
                if(!brotate)
                {
                    rotate_single_left(t);
                    brotate = true;
                }
                return true;
            }
            else
            {
                return false;
            }
        }
        else if( x>t->element )
        {
            if(contains(x, t->right, brotate))
            {
                if(!brotate)
                {
                    rotate_single_right(t);
                    brotate = true;
                }
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            if(!t->isdeleted)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }

    // 插入节点
    void insert(const T& x, tree_node*& t)
    {
        if( t == NULL )
        {
            t = new tree_node(x,NULL,NULL);
        }
        else if( x<t->element)
        {
            insert(x,t->left);
        }
        else if( x>t->element )
        {
            insert(x,t->right);
        }
        else
        {
            if(t->isdeleted)
            {
                t->isdeleted = false;
            }
        }
    }

    // 移除某节点
    void remove(const T& x, 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 = min( t->right )->element;
            //remove( t->element, t->right);
            t->isdeleted = true;
        }
        else
        {
            //splay_tree_node *old_node = t;
            //t = (t->left != NULL)?t->left:t->right;
            //delete old_node;
            t->isdeleted = true;
        }
    }

    // 清除该节点为根节点的树
    void clear(tree_node*& t)
    {
        if(t != NULL)
        {
            clear(t->left);
            clear(t->right);
            delete t;
            t = NULL;
        }
    }

    // 对该节点的为根节点的树的所有子节点执行某项动作
    template<typename Functor>
    void foreach(tree_node* t, Functor& functor)
    {
        if(t!=NULL)
        {
            functor(t);
            foreach(t->left, functor);
            foreach(t->right, functor);
        }
    }

    // 深拷贝树
    tree_node* clone(tree_node* t) const
    {
        if( t==NULL )
        {
            return NULL;
        }
        return new tree_node(t->element, clone(t->left), clone(t->right));
    }

    // 单旋转-LL
    void rotate_single_left(tree_node*& k2)
    {
        tree_node* k1 = k2->left;
        k2->left = k1->right;
        k1->right = k2;
        k2 = k1;
    }

    // 单旋转-RR
    void rotate_single_right(tree_node*& k2)
    {
        tree_node* k1 = k2->right;
        k2->right = k1->left;
        k1->left = k2;
        k2 = k1;
    }

private:
    tree_node    *m_root;
};