MiYu原创, 转帖请注明 : 转载自 ______________白白の屋    

 

伸展树(Splay Tree)是AVL树不错的替代,它有以下几个特点:
(1)它是二叉查找树的改进,所以具有二叉查找树的有序性。
(2)对伸展树的操作的平摊复杂度是O(log2n)。
(3)伸展树的空间要求、编程难度非常低。

提到伸展树,就不得不提到AVL树和Read-Black树,虽然这两种树能够保证各种操作在最坏情况下都为logN,但是两都实现都比较复杂。而在实际情况中,90%的访问发生在10%的数据上。因此,我们可以重构树的结构,使得被经常访问的节点朝树根的方向移动。尽管这会引入额外的操作,但是经常被访问的节点被移动到了靠近根的位置,因此,对于这部分节点,我们可以很快的访问。这样,就能使得平摊复杂度为logN。

1、自底向上的伸展树
伸展操作Splay(x,S)是在保持伸展树有序性的前提下,通过一系列旋转操作将伸展树S中的元素x调整至树的根部的操作。
在旋转的过程中,要分三种情况分别处理:
(1)Zig 或 Zag
(2)Zig-Zig 或 Zag-Zag
(3)Zig-Zag 或 Zag-Zig
1.1、Zig或Zag操作
节点x的父节点y是根节点。

1.2、Zig-Zig或Zag-Zag操作
节点x的父节点y不是根节点,且x与y同时是各自父节点的左孩子或者同时是各自父节点的右孩子。

1.3、Zig-Zag或Zag-Zig操作
节点x的父节点y不是根节点,x与y中一个是其父节点的左孩子而另一个是其父节点的右孩子。

2、自顶向下的伸展树
    在自底向上的伸展树中,我们需要求一个节点的父节点和祖父节点,因此这种伸展树难以实现。因此,我们可以构建自顶向下的伸展树。
    当我们沿着树向下搜索某个节点X的时候,我们将搜索路径上的节点及其子树移走。我们构建两棵临时的树──左树和右树。没有被移走的节点构成的树称作中树。在伸展操作的过程中:
(1)当前节点X是中树的根。
(2)左树L保存小于X的节点。
(3)右树R保存大于X的节点。
开始时候,X是树T的根,左右树L和R都是空的。和前面的自下而上相同,自上而下也分三种情况:
2.1、Zig操作

如上图,在搜索到X的时候,所查找的节点比X小,将Y旋转到中树的树根。旋转之后,X及其右子树被移动到右树上。很显然,右树上的节点都大于所要查找的节点。注意X被放置在右树的最小的位置,也就是X及其子树比原先的右树中所有的节点都要小。这是由于越是在路径前面被移动到右树的节点,其值越大。

2.2、Zig-Zig操作

这种情况下,所查找的节点在Z的子树中,也就是,所查找的节点比X和Y都小。所以要将X,Y及其右子树都移动到右树中。首先是Y绕X右旋,然后Z绕Y右旋,最后将Z的右子树(此时Z的右子节点为Y)移动到右树中。

2.3、Zig-Zag操作

这种情况中,首先将Y右旋到根。这和Zig的情况是一样的,然后变成上图右边所示的形状。此时,就与Zag(与Zig相反)的情况一样了。

最后,在查找到节点后,将三棵树合并。如图:


2.4、示例:
下面是一个查找节点19的例子。在例子中,树中并没有节点19,最后,距离节点最近的节点18被旋转到了根作为新的根。节点20也是距离节点19最近的节点,但是节点20没有成为新根,这和节点20在原来树中的位置有关系。

3、实现
3.1、splay操作

代码
tree_node * splay (int i, tree_node * t) {
    tree_node N, *l, *r, *y;
    if (t == NULL) 
        return t;
    N.left = N.right = NULL;
    l = r = &N;

    for (;;)
    {
        if (i < t->item) 
        {
            if (t->left == NULL) 
                break;
            if (i < t->left->item) 
            {
                y = t->left;                           /* rotate right */
                t->left = y->right;
                y->right = t;
                t = y;
                if (t->left == NULL) 
                    break;
            }
            r->left = t;                               /* link right */
            r = t;
            t = t->left;
        } else if (i > t->item)
        {
            if (t->right == NULL) 
                break;
            if (i > t->right->item) 
            {
                y = t->right;                          /* rotate left */
                t->right = y->left;
                y->left = t;
                t = y;
                if (t->right == NULL) 
                    break;
            }
            l->right = t;                              /* link left */
            l = t;
            t = t->right;
        } else {
            break;
        }
    }
    l->right = t->left;                                /* assemble */
    r->left = t->right;
    t->left = N.right;
    t->right = N.left;
    return t;
}

Rotate right(查找10):

Link right:

Assemble:

Rotate left(查找20):

Link left:

3.2、插入操作

代码
  /*
  **将i插入树t中,返回树的根结点(item值==i)
  */
  tree_node* ST_insert(int i, tree_node *t) {
      /* Insert i into the tree t, unless it's already there.    */
      /* Return a pointer to the resulting tree.                 */
      tree_node* node;
      
      node = (tree_node *) malloc (sizeof (tree_node));
     if (node == NULL){
         printf("Ran out of space\n");
         exit(1);
     }
     node->item = i;
     if (t == NULL) {
         node->left = node->right = NULL;
         size = 1;
         return node;
     }
     t = splay(i,t);
     if (i < t->item) {  //令t为i的右子树
         node->left = t->left;
         node->right = t;
         t->left = NULL;
         size ++;
         return node;
     } else if (i > t->item) { //令t为i的左子树
         node->right = t->right;
         node->left = t;
         t->right = NULL;
         size++;
         return node;
     } else { 
         free(node); //i值已经存在于树t中
         return t;
     }
 }

3.3、删除操作

代码
  /*
 **从树中删除i,返回树的根结点
 */
 tree_node* ST_delete(int i, tree_node* t) {
     /* Deletes i from the tree if it's there.               */
     /* Return a pointer to the resulting tree.              */
     tree_node* x;
     if (t==NULL) 
         return NULL;
     t = splay(i,t);
     if (i == t->item) {               /* found it */
         if (t->left == NULL) { //左子树为空,则x指向右子树即可
           x = t->right;
         } else {
             x = splay(i, t->left); //查找左子树中最大结点max,令右子树为max的右子树
             x->right = t->right;
         }
         size--;
         free(t);
         return x;
     }
     return t;                         /* It wasn't there */
 }

完整代码:

代码
#include <stdio.h>
#include <stdlib.h>

int     size; //结点数量

#define        NUM        20

typedef struct tree_node{
    struct tree_node*    left;
    struct tree_node*    right;
    int        item;
}tree_node;

tree_node* splay (int i, tree_node* t) {
    tree_node N, *l, *r, *y;

    if (t == NULL) 
        return t;

    N.left = N.right = NULL;
     l = r = &N;
 
     for (;;)
     {
         if (i < t->item) 
         {
             if (t->left == NULL) 
                 break;
             if (i < t->left->item) 
             {
                 y = t->left;                           /* rotate right */
                 t->left = y->right;
                 y->right = t;
                 t = y;
                 if (t->left == NULL) 
                     break;
             }
             r->left = t;                               /* link right */
            r = t;
             t = t->left;
         } else if (i > t->item)
         {
             if (t->right == NULL) 
                 break;
             if (i > t->right->item) 
             {
                 y = t->right;                          /* rotate left */
                 t->right = y->left;
                 y->left = t;
                 t = y;
                 if (t->right == NULL) 
                     break;
             }
             l->right = t;                              /* link left */
             l = t;
             t = t->right;
         } else {
             break;
         }
     }
     l->right = t->left;                                /* assemble */
     r->left = t->right;
     t->left = N.right;
     t->right = N.left;
     return t;
 }
 
 /*
 **将i插入树t中,返回树的根结点(item值==i)
 */
 tree_node* ST_insert(int i, tree_node *t) {
     /* Insert i into the tree t, unless it's already there.    */
     /* Return a pointer to the resulting tree.                 */
     tree_node* node;
     
     node = (tree_node *) malloc (sizeof (tree_node));
     if (node == NULL){
         printf("Ran out of space\n");
         exit(1);
     }
     node->item = i;
     if (t == NULL) {
         node->left = node->right = NULL;
         size = 1;
         return node;
     }
     t = splay(i,t);
     if (i < t->item) {  //令t为i的右子树
         node->left = t->left;
         node->right = t;
         t->left = NULL;
         size ++;
         return node;
     } else if (i > t->item) { //令t为i的左子树
         node->right = t->right;
         node->left = t;
         t->right = NULL;
         size++;
         return node;
    } else { 
         free(node); //i值已经存在于树t中
         return t;
     }
 }
 
 
 /*
 **从树中删除i,返回树的根结点
 */
 tree_node* ST_delete(int i, tree_node* t) {
     /* Deletes i from the tree if it's there.               */
     /* Return a pointer to the resulting tree.              */
     tree_node* x;
     if (t==NULL) 
         return NULL;
     t = splay(i,t);
     if (i == t->item) {               /* found it */
         if (t->left == NULL) { //左子树为空,则x指向右子树即可
             x = t->right;
         } else {
             x = splay(i, t->left); //查找左子树中最大结点max,令右子树为max的右子树
             x->right = t->right;
         }
         size--;
         free(t);
         return x;
     }
     return t;                         /* It wasn't there */
 }
 
 void ST_inoder_traverse(tree_node*    node)
 {
     if(node != NULL)
     {
         ST_inoder_traverse(node->left);
         printf("%d ", node->item);
         ST_inoder_traverse(node->right);
     }
 }
 
 void ST_pre_traverse(tree_node*    node)
 {
     if(node != NULL)
    {
         printf("%d ", node->item);
         ST_pre_traverse(node->left);
         ST_pre_traverse(node->right);
     }
 }
 
 
 void main() {
     /* A sample use of these functions.  Start with the empty tree,         */
     /* insert some stuff into it, and then delete it                        */
     tree_node* root;
     int i;
 
     root = NULL;              /* the empty tree */
     size = 0;
 
     for(i = 0; i < NUM; i++)
         root = ST_insert(rand()%NUM, root);
 
     ST_pre_traverse(root);
     printf("\n");
     ST_inoder_traverse(root);
 
     for(i = 0; i < NUM; i++)
         root = ST_delete(i, root);
 
     printf("\nsize = %d\n", size);
 }
 

 

 posted on 2010-11-12 11:13  MiYu  阅读(1103)  评论(0编辑  收藏  举报