伸展树（SplayTree）的实现

优点：伸展树(splay tree)是一种能自我调整的二叉搜索树(BST)。虽然某一次的访问操作所花费的时间比较长，但是平摊（amortized） 之后的访问操作（例如旋转）时间能达到O(logn)的复杂度。对于某一个被访问的节点，在接下来的一段时间内再次频繁访问它（90%的情况下是这样的，即符合90-10规则，类似于CPU内或磁盘的cache设计原理）的应用模式来说，伸展树是一种很理想的数据结构。另外一点与其他平衡二叉树的区别是，伸展树不需要存储任何像AVL树中平衡因子(balance factor)那样的平衡信息，可以节省空间的开销。

缺点：不像其他平衡二叉树那样即使最坏情况下也能达到O(logn)访问时间，它的最坏情况下只有O(n)，跟单向链表一样。另外，伸展树的查找操作会修改树的结构，这与普通意义上的查找为只读操作习惯不太一样。

实现方式：伸展树的实现有两种方式，一是自底向上(bottom-up)，另外一种是自顶向下(top-down)。

考虑到实现的难易程度，自顶向下的实现方式比较简单，因为自底向上需要保存已经被访问的节点，而自顶向下可以在搜索的过程中同时完成splay操作。

虽然两者得出的树结构不太一样，但是它们的平摊时间复杂度都是O(logn)。两种实现的基本操作就是splay，splay将最后被访问到的节点提升为根节点。

在自顶向下(top-down)的实现中，需要将输入的树拆成三颗树，分别为左树L，中树M和右树R。其中M树维护当前还未被访问到的节点，L树中所有节点的值都小于M树中的任何节点值，R树中所有节点的值都大于M树中的任何节点值。L树中只需要知道当前的最大节点 (leftTreeMax)，而R树中只需要知道当前的最小节点(rightTreeMin)。左右两棵树的根节点分别可以通过nullNode节点（它是leftTreeMax和rightTreeMin的初始值，而且splay过程中变量nullNode本身未变化,只改变它的左右孩子节点）的右和左孩子节点得到，因为leftTreeMax中加入一个新的节点或子树时都是将新的节点作为leftTreeMax的右孩子，而不是左孩子（注意这里的顺序），rightTreeMin跟leftTreeMax相反。自顶向下的zig-zig或zag-zag需要做旋转操作，zig-zig的旋转操作叫rotationWithLeftChild,旋转后目标节点的父节点和祖父节点加入R树，zag-zag的旋转操作叫rotationWithRightChild,旋转后目标节点的父节点和祖父节点加入L树。另外zig-zag或zag-zig可以分别简化为zig或zag操作，这样可以将zig-zag和zig合二为一，从而只需考虑一种情况，而不需要将两种情况单独考虑。zig操作将目标节点的父节点加入R树，zag操作将目标节点的父节点加入L树。注意L和R树中每次加入新节点都需更新变量leftTreeMax或rightTreeMin。自顶向下splay操作的最后一步是重组(re-assemble)：将M树的左孩子设置为L树的根节点，将M树的右孩子设置为R树的根节点，然后M树原来的左孩子成为leftTreeMax的右孩子，M树原来的右孩子成为rightTreeMin的左孩子。

注：rotationWithRightChild和rotationWithLeftChild的实现省略。

以下是类定义

#ifndef _splaytree_h_
#define _splaytree_h_

template<typename Comparable>
class SplayTree
{
public:
    SplayTree()
    {
        nullNode = new BinaryNode;
        nullNode->left = nullNode->right = nullNode;
        root = nullNode;
    }

    ~SplayTree()
    {
        makeEmpty();
        delete nullNode;
    }

    SplayTree(const Splay& rhs);
    const SplayTree& operator=(const SplayTree&rhs);
　　 // 此处省略操作方法

private:
    struct BinaryNode
    {
        Comparable element;
        BinaryNode *left;
        BinaryNode *right;

        BinaryNode(const Comparable& theElement, BinaryNode *lt, BinaryNode* rt) :element(theElement), left(lt), right(rt){}
    };

    BinaryNode *root;
    BinaryNode *nullNode;
// Internal method to perform a top-down splay.
    void insert(const Comparable& x, BinaryNode*&t)const;
    void remove(const Comparable& x, BinaryNode*&t)const;
    BinaryNode* findMin(BinaryNode* t)const;
    BinaryNode* findMax(BinaryNode* t)const;
    bool contains(const Comparable&x, BinaryNode*t)const;
    void makeEmpty(BinaryNode*&t);
    void printTree(BinaryNode*t)const;
    BinaryNode* clone(BinaryNode*t)const;

    void rotationWithLeftChild(BinaryNode*&k2);
    void rotationWithRightChild(BinaryNode*& k1);
    void splay(const Comparable& x, BinaryNode *&t);
};

#endif

接着splay的实现： 1 #include"splaytree.h"

template<typename Comparable>
void SplayTree<Comparable>::splay(const Comparable& x, BinaryNode*& t)
{
    BinaryNode *leftTreeMax, *rightTreeMin;
    static BinaryNode header;

    header.left = header.right = nullNode;         //nullNode逻辑上表示一个NULL指针
    leftTreeMax = rightTreeMin = &header;  

    nullNode->element = x;   //guarantee a match.

    for (;;)                    
        if (x < t->element)
        {
            if ((x < t->left->element))
                rotationWithLeftChild(t); 
            if (t->left == nullNode)
                break;
　　　　　　　　　　　　// Link Right
            rightTreeMin->left = t;
            rightTreeMin = t;
            t = t->left;
        }
        else if (t->element < x)
        {
            if (t->right->element < x)
                rotationWithRightChild(t);
            if (t->right == nullNode)
                break;
　　　　　　　　　　　　// Link Left
            leftTreeMax->right = t;
            leftTreeMax = t;
            t = t->right;
        }
        else
            break;

        leftTreeMax->right = t->left;
        rightTreeMin->left = t->right;
        t->left = header.right;
        t->right = header.left;
}

 header.left和header.right分别引用R和L的根。（这不是输入错误，而是遵守链的指向）

void insert(const Comparable& x)
{
    static BinaryNode* newNode = NULL; 
    if (newNode == NULL)
        newNode = new BinaryNode;
    newNode->element = x;

    if (root == nullNode)
    {
        newNode->left = newNode->right = nullNode;
        root = newNode;
    }
    else
    {
        splay(x, root);
        if (x < root->element)
        {
            newNode->left = root->right;
            newNode->right = root;
            root->left = nullNode;
            root = newNode;
        }
        else if (root->element < x)
        {
            newNode->right = root->right;
            newNode.left = root;
            root->right = nullNode;
            root = newNode;
        }
        else
            return;
    }
    newNode = NULL; // So next insert will call new.
}

 remove和makeEmpty的实现：

void remove(const Comparable& x)
{
    BinaryNode *newNode;
    splay(x, root);
    if (root->element != x)
        return;
    if (root->left == nullNode)
        newTree = root->right;
    else
    {
        newTree = root->left;
        splay(x, newTree);   // 在左子树中寻找最大的项，把它伸展到根部
        newTree->right = root->right; //连接右子树
    }
    delete root;
    root = newTree;
}

void makeEmpty()
{
    whiel(!isEmpty())
    {
        findMax();
        remove(root->element);
    }
}