关闭

伸展树的代码实现

标签: 数据结构
255人阅读 评论(0) 收藏 举报
分类:

一、伸展树的数据结构

typedef struct Node
{
    int key;    
    struct Node *lch,*rch,*parent;
}* Node ,* Tree;

二、伸展树的基础操作

下面几个函数中,设x 的父节点为 p, p的父节点为g 。

  • zig( t , x )
    右旋。当p是根节点,x是p的左孩子,将x右旋。
    这里写图片描述
    代码如下:
//单次右旋以 root 节点 为根节点的树 
Node zig( Tree tree , Node root)
{
    Node lc = root->lch;
    Node parent = root->parent;

    //处理父节点关系 
    if( parent )
    {
        if( root == parent->lch )
        {
            parent->lch = lc;
        }else{
            parent->rch = lc;
        }
        lc->parent = parent;
    }else{
        lc->parent = NULL;
    }

    //翻转 
    if( lc != NULL )
    {
        root->lch = lc->rch;
        if( lc->rch )
        {
            lc->rch->parent = root;
        } 
        lc->rch = root;
        root->parent = lc;
        if( parent )
        {
            return tree;
        }else{
            return lc;  
        }

    }
    return tree;
}
  • zag( t , x )
    左旋。当p是根节点,x是p的右孩子,将x左旋
//单次左旋以 root 节点 为根节点的树 
Node zag( Tree tree , Node root)
{
    Node rc = root->rch;
    Node parent = root->parent;
    //处理父节点关系 
    if( parent )
    {
        if( root == parent->lch )
        {
            parent->lch = rc;
        }else{
            parent->rch = rc;
        }
        rc->parent = parent;
    }else{
        rc->parent = NULL;
    }
    //翻转 
    if( rc != NULL )
    {
        root->rch = rc->lch;
        if( rc->lch )
        {
            rc->lch->parent = root;
        } 
        rc->lch = root;
        root->parent = rc;
        if( parent )
        {
            return tree;
        }else{
            return rc;  
        }
    }
    return tree;
}
  • zig_zig( t , x )
    右双旋。x是p的左节点,当p是g的左节点,先将p右旋,再将x右旋
//右双旋以 root 节点 为根节点的树 
Node zig_zig( Tree tree , Node root)
{
    Node lc = root->lch;
    Node node=zig( tree , root );
    return zig( node , lc );
}
  • zag_zag( t , x )
    左双旋。x是p的右节点,当p是g的右节点,先将p左旋,再将x左旋
//左双旋以 root 节点 为根节点的树 
Node zag_zag( Tree tree , Node root)
{
    Node rc = root->rch;
    Node node=zag( tree , root );
    return zag( node , rc );
}
  • zig_zag( t , x )
    右旋再左旋。x是p的左节点,当p是g的右节点,先将x右旋,再将x左旋
Node zig_zag( Tree tree , Node root)
{
    Node node=zig( tree , root->rch );
    return zag( node , root );
}
  • zag_zig( t , x )
    左旋再右旋。x是p的右节点,当p是g的左节点,先将x左旋,再将x右旋
Node zag_zig( Tree tree , Node root)
{
    Node node=zag( tree , root->lch ); 
    return zig( node , root );
}
  • zig_zag_manager( t , x)
    旋转管理者。 找到x,分析x与父亲节点,父亲节点与祖父节点的关系,选择恰当的旋转方式。
//根据目标节点的结构选择相应的算法,策略模式 
Node zig_zag_manager( Tree tree , Node node )
{ 
    Node parent = node->parent;
    if( parent == tree  )    //1
    {
        if( parent->lch == node )
        {
            return zig( tree , parent );
        }else{
            return zag( tree , parent );
        }

    }else if(  parent->lch == node ){ //2
        Node grand = parent->parent;    
        if( grand->lch == parent ){ /*左左*/
            return zig_zig( tree , grand ); 
        }else{                      /*右左*/ 
            return zig_zag( tree , grand );
        }

    }else if( parent->rch == node ){ //3

        Node grand = parent->parent;    
        if( grand->lch == parent ){ /*左右*/
            return zag_zig( tree , grand ); 
        }else{                      /*右右*/
            return zag_zag( tree , grand );
        }
    }

    return tree;
}
  • splay( t ,x )
    将x调至根部。循环调用zig_zag_manager( t , x) 方法,直到x == t
//将目标节点调整到树的根部,并返回树根 
Node splay(Tree tree , Node node)
{
    while( node->parent!=NULL )
    {
        zig_zag_manager( tree , node );
    }
    return node;
}
  • find( t , x )
    找到x。找到x,然后将x旋转到树根。
//寻找key节点 
Node find( Tree tree , int key )
{
    Node curr = tree;
    while( curr != NULL )
    {
        if( curr->key == key ){
            splay( tree , curr );
            return curr;    
        } else if( curr->key > key ){
            curr = curr->lch;
        }else{
            curr = curr->rch;
        }
    }
    return NULL;
}
  • spilt( t , x)
    以x为界分离t。找到x,将x旋转到树根,然后将x的左子树和剩余部分分离
//以 node 为届,分离 tree 的左子树 ,返回剩余部分 
Node spilt( Tree tree , Node node )
{
    tree = splay( tree , node ); //将 node 调至根部
    Node lc = tree->lch;
    tree->lch = NULL;
    if( lc ) 
    {
        lc->parent = NULL;
    }
    return tree;
}

注意这里,要获得左子树可以在分离之前获得。

  • join( t1 , t2 )
    合并子树 t1和t2,要求t1所有元素小于t2的任一元素。找到t1的最大元素,并调整到根部,将t2作为根的右子树插入
//合并tree1 和 tree2 ,要求 tree1 所有元素小于 tree2 任一元素 
Node join( Tree tree1, Tree tree2)
{
    //找打 tree1 中最大的元素 
    Node temp = tree1;
    while( temp->rch != NULL )
    {
        temp = temp->rch;
    } 
    //将 temp调至 tree1的根部 
    splay( tree1 ,temp );
    //将 tree2 作为 temp的右子树
    temp->rch = tree2;
    tree2->parent = temp;
    return temp; 
}

附件:
1. C-free工程,也可直接打开文件.zip
2. 广东工业大学-计算机学院-伸展树.pdf

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:151756次
    • 积分:2888
    • 等级:
    • 排名:第13940名
    • 原创:135篇
    • 转载:0篇
    • 译文:5篇
    • 评论:38条
    博客专栏