八、【樹形結構】伸展樹

1、伸展樹的介紹

伸展樹(Splay Tree)是一種二叉排序樹，它能在O(log n)內完成插入、查找和刪除操做。它由Daniel Sleator和Robert Tarjan創造。
　　(1) 伸展樹屬於二叉查找樹，即它具備和二叉查找樹同樣的性質：假設x爲樹中的任意一個結點，x節點包含關鍵字key，節點x的key值記爲key[x]。若是y是x的左子樹中的一個結點，則key[y] <= key[x]；若是y是x的右子樹的一個結點，則key[y] >= key[x]。
　　(2) 除了擁有二叉查找樹的性質以外，伸展樹還具備的一個特色是：當某個節點被訪問時，伸展樹會經過旋轉使該節點成爲樹根。這樣作的好處是，下次要訪問該節點時，可以迅速的訪問到該節點。

假設想要對一個二叉查找樹執行一系列的查找操做。爲了使整個查找時間更小，被查頻率高的那些條目就應當常常處於靠近樹根的位置。因而想到設計一個簡單方法，在每次查找以後對樹進行重構，把被查找的條目搬移到離樹根近一些的地方。伸展樹應運而生，它是一種自調整形式的二叉查找樹，它會沿着從某個節點到樹根之間的路徑，經過一系列的旋轉把這個節點搬移到樹根去。

相比於"二叉查找樹"和"AVL樹"，學習伸展樹時須要重點關注是"伸展樹的旋轉算法"。

2、伸展樹的C++實現

1. 基本定義
1.1 節點

 1 template <class T>
 2 class SplayTreeNode{
 3     public:
 4         T key;                // 關鍵字(鍵值)
 5         SplayTreeNode *left;    // 左孩子
 6         SplayTreeNode *right;    // 右孩子
 7 
 8 
 9         SplayTreeNode():left(NULL),right(NULL) {}
10 
11         SplayTreeNode(T value, SplayTreeNode *l, SplayTreeNode *r):
12             key(value), left(l),right(r) {}
13 };

SplayTreeNode是伸展樹節點對應的類。它包括的幾個組成元素:
　　(1) key -- 是關鍵字，是用來對伸展樹的節點進行排序的。
　　(2) left -- 是左孩子。
　　(3) right -- 是右孩子。

1.2 伸展樹

template <class T>
class SplayTree {
    private:
        SplayTreeNode<T> *mRoot;    // 根結點

    public:
        SplayTree();
        ~SplayTree();

        // 前序遍歷"伸展樹"
        void preOrder();
        // 中序遍歷"伸展樹"
        void inOrder();
        // 後序遍歷"伸展樹"
        void postOrder();

        // (遞歸實現)查找"伸展樹"中鍵值爲key的節點
        SplayTreeNode<T>* search(T key);
        // (非遞歸實現)查找"伸展樹"中鍵值爲key的節點
        SplayTreeNode<T>* iterativeSearch(T key);

        // 查找最小結點：返回最小結點的鍵值。
        T minimum();
        // 查找最大結點：返回最大結點的鍵值。
        T maximum();

        // 旋轉key對應的節點爲根節點，並返回值爲根節點。
        void splay(T key);

        // 將結點(key爲節點鍵值)插入到伸展樹中
        void insert(T key);

        // 刪除結點(key爲節點鍵值)
        void remove(T key);

        // 銷燬伸展樹
        void destroy();

        // 打印伸展樹
        void print();
    private:

        // 前序遍歷"伸展樹"
        void preOrder(SplayTreeNode<T>* tree) const;
        // 中序遍歷"伸展樹"
        void inOrder(SplayTreeNode<T>* tree) const;
        // 後序遍歷"伸展樹"
        void postOrder(SplayTreeNode<T>* tree) const;

        // (遞歸實現)查找"伸展樹x"中鍵值爲key的節點
        SplayTreeNode<T>* search(SplayTreeNode<T>* x, T key) const;
        // (非遞歸實現)查找"伸展樹x"中鍵值爲key的節點
        SplayTreeNode<T>* iterativeSearch(SplayTreeNode<T>* x, T key) const;

        // 查找最小結點：返回tree爲根結點的伸展樹的最小結點。
        SplayTreeNode<T>* minimum(SplayTreeNode<T>* tree);
        // 查找最大結點：返回tree爲根結點的伸展樹的最大結點。
        SplayTreeNode<T>* maximum(SplayTreeNode<T>* tree);

        // 旋轉key對應的節點爲根節點，並返回值爲根節點。
        SplayTreeNode<T>* splay(SplayTreeNode<T>* tree, T key);

        // 將結點(z)插入到伸展樹(tree)中
        SplayTreeNode<T>* insert(SplayTreeNode<T>* &tree, SplayTreeNode<T>* z);

        // 刪除伸展樹(tree)中的結點(鍵值爲key)，並返回被刪除的結點
        SplayTreeNode<T>* remove(SplayTreeNode<T>* &tree, T key);

        // 銷燬伸展樹
        void destroy(SplayTreeNode<T>* &tree);

        // 打印伸展樹
        void print(SplayTreeNode<T>* tree, T key, int direction);
};

2. 旋轉

旋轉是伸展樹中須要重點關注的，它的代碼以下：

 1 /* 
 2  * 旋轉key對應的節點爲根節點，並返回值爲根節點。
 3  *
 4  * 注意：
 5  *   (a)：伸展樹中存在"鍵值爲key的節點"。
 6  *          將"鍵值爲key的節點"旋轉爲根節點。
 7  *   (b)：伸展樹中不存在"鍵值爲key的節點"，而且key < tree->key。
 8  *      b-1 "鍵值爲key的節點"的前驅節點存在的話，將"鍵值爲key的節點"的前驅節點旋轉爲根節點。
 9  *      b-2 "鍵值爲key的節點"的前驅節點存在的話，則意味着，key比樹中任何鍵值都小，那麼此時，將最小節點旋轉爲根節點。
10  *   (c)：伸展樹中不存在"鍵值爲key的節點"，而且key > tree->key。
11  *      c-1 "鍵值爲key的節點"的後繼節點存在的話，將"鍵值爲key的節點"的後繼節點旋轉爲根節點。
12  *      c-2 "鍵值爲key的節點"的後繼節點不存在的話，則意味着，key比樹中任何鍵值都大，那麼此時，將最大節點旋轉爲根節點。
13  */
14 template <class T>
15 SplayTreeNode<T>* SplayTree<T>::splay(SplayTreeNode<T>* tree, T key)
16 {
17     SplayTreeNode<T> N, *l, *r, *c;
18 
19     if (tree == NULL) 
20         return tree;
21 
22     N.left = N.right = NULL;
23     l = r = &N;
24 
25     for (;;)
26     {
27         if (key < tree->key)
28         {
29             if (tree->left == NULL)
30                 break;
31             if (key < tree->left->key)
32             {
33                 c = tree->left;                           /* rotate right */
34                 tree->left = c->right;
35                 c->right = tree;
36                 tree = c;
37                 if (tree->left == NULL) 
38                     break;
39             }
40             r->left = tree;                               /* link right */
41             r = tree;
42             tree = tree->left;
43         }
44         else if (key > tree->key)
45         {
46             if (tree->right == NULL) 
47                 break;
48             if (key > tree->right->key) 
49             {
50                 c = tree->right;                          /* rotate left */
51                 tree->right = c->left;
52                 c->left = tree;
53                 tree = c;
54                 if (tree->right == NULL) 
55                     break;
56             }
57             l->right = tree;                              /* link left */
58             l = tree;
59             tree = tree->right;
60         }
61         else
62         {
63             break;
64         }
65     }
66 
67     l->right = tree->left;                                /* assemble */
68     r->left = tree->right;
69     tree->left = N.right;
70     tree->right = N.left;
71 
72     return tree;
73 }
74 
75 template <class T>
76 void SplayTree<T>::splay(T key)
77 {
78     mRoot = splay(mRoot, key);
79 }

上面的代碼的做用：將"鍵值爲key的節點"旋轉爲根節點，並返回根節點。它的處理狀況共包括：
(a)：伸展樹中存在"鍵值爲key的節點"。
        將"鍵值爲key的節點"旋轉爲根節點。
(b)：伸展樹中不存在"鍵值爲key的節點"，而且key < tree->key。
        b-1) "鍵值爲key的節點"的前驅節點存在的話，將"鍵值爲key的節點"的前驅節點旋轉爲根節點。
        b-2) "鍵值爲key的節點"的前驅節點存在的話，則意味着，key比樹中任何鍵值都小，那麼此時，將最小節點旋轉爲根節點。
(c)：伸展樹中不存在"鍵值爲key的節點"，而且key > tree->key。
        c-1) "鍵值爲key的節點"的後繼節點存在的話，將"鍵值爲key的節點"的後繼節點旋轉爲根節點。
        c-2) "鍵值爲key的節點"的後繼節點不存在的話，則意味着，key比樹中任何鍵值都大，那麼此時，將最大節點旋轉爲根節點。

3. 插入

插入代碼

 1 /* 
 2  * 將結點插入到伸展樹中，並返回根節點
 3  *
 4  * 參數說明：
 5  *     tree 伸展樹的根結點
 6  *     key 插入的結點的鍵值
 7  * 返回值：
 8  *     根節點
 9  */
10 template <class T>
11 SplayTreeNode<T>* SplayTree<T>::insert(SplayTreeNode<T>* &tree, SplayTreeNode<T>* z)
12 {
13     SplayTreeNode<T> *y = NULL;
14     SplayTreeNode<T> *x = tree;
15 
16     // 查找z的插入位置
17     while (x != NULL)
18     {
19         y = x;
20         if (z->key < x->key)
21             x = x->left;
22         else if (z->key > x->key)
23             x = x->right;
24         else
25         {
26             cout << "不容許插入相同節點(" << z->key << ")!" << endl;
27             delete z;
28             return tree;
29         }
30     }
31 
32     if (y==NULL)
33         tree = z;
34     else if (z->key < y->key)
35         y->left = z;
36     else
37         y->right = z;
38 
39     return tree;
40 }
41 
42 template <class T>
43 void SplayTree<T>::insert(T key)
44 {
45     SplayTreeNode<T> *z=NULL;
46 
47     // 若是新建結點失敗，則返回。
48     if ((z=new SplayTreeNode<T>(key,NULL,NULL)) == NULL)
49         return ;
50 
51     // 插入節點
52     mRoot = insert(mRoot, z);
53     // 將節點(key)旋轉爲根節點
54     mRoot = splay(mRoot, key);
55 }

insert(key)是提供給外部的接口，它的做用是新建節點(節點的鍵值爲key)，並將節點插入到伸展樹中；而後，將該節點旋轉爲根節點。
insert(tree, z)是內部接口，它的做用是將節點z插入到tree中。insert(tree, z)在將z插入到tree中時，僅僅只將tree看成是一棵二叉查找樹，並且不容許插入相同節點。

4. 刪除

刪除代碼

 1 /* 
 2  * 刪除結點(節點的鍵值爲key)，返回根節點
 3  *
 4  * 參數說明：
 5  *     tree 伸展樹的根結點
 6  *     key 待刪除結點的鍵值
 7  * 返回值：
 8  *     根節點
 9  */
10 template <class T>
11 SplayTreeNode<T>* SplayTree<T>::remove(SplayTreeNode<T>* &tree, T key)
12 {
13     SplayTreeNode<T> *x;
14 
15     if (tree == NULL) 
16         return NULL;
17 
18     // 查找鍵值爲key的節點，找不到的話直接返回。
19     if (search(tree, key) == NULL)
20         return tree;
21 
22     // 將key對應的節點旋轉爲根節點。
23     tree = splay(tree, key);
24 
25     if (tree->left != NULL)
26     {
27         // 將"tree的前驅節點"旋轉爲根節點
28         x = splay(tree->left, key);
29         // 移除tree節點
30         x->right = tree->right;
31     }
32     else
33         x = tree->right;
34 
35     delete tree;
36 
37     return x;
38 
39 }
40 
41 template <class T>
42 void SplayTree<T>::remove(T key)
43 {
44     mRoot = remove(mRoot, key);
45 }

remove(key)是外部接口，remove(tree, key)是內部接口。
remove(tree, key)的做用是：刪除伸展樹中鍵值爲key的節點。
它會先在伸展樹中查找鍵值爲key的節點。若沒有找到的話，則直接返回。若找到的話，則將該節點旋轉爲根節點，而後再刪除該節點。