8树形结构伸展树

Posted 2021-01-12 long-w

一、伸展树的介绍

伸展树(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树"，学习伸展树时需要重点关注是"伸展树的旋转算法"。

二、伸展树的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的节点。若没有找到的话，则直接返回。若找到的话，则将该节点旋转为根节点，然后再删除该节点。