伸展树Splay Tree

最新推荐文章于 2019-02-23 02:34:27 发布
最新推荐文章于 2019-02-23 02:34:27 发布
阅读量710 收藏 2
点赞数
分类专栏： 算法学习 文章标签： tree 伸展树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yiluoyan/article/details/45787055
版权

伸展树

与平衡树（AVL）一样，伸展树（splay tree）也是二叉树的一种，它能在O(log n)内完成插入、删除和查找操作。

伸展树的特点：
1. 假设当前节点X的关键值为key，则X左子树的节点y的键值key[y] < key. 右子树节点z的键值key[z] > key.
2. 当某个节点被访问时，伸展树会通过旋转使得该节点成为树根(root)。使得下次访问该节点时，能够迅速访问到节点。

伸展树的实现

1.节点定义

与二叉树的节点定义一样：

typedef int Type;
typedef struct SplayTreeNode
{
    Type key;  //关键字
    struct SplayTreeNode *left;  //左子树
    struct SplayTreeNode *right; //右子树
}Node, *SplayTree;

2.伸展树的遍历

作为二叉树的一种，同样具有前序遍历、中序遍历、后序遍历三种遍历树的方法，这里巩固一下三种方法的实现：

//前序遍历伸展树
void preorder_splaytree(SplayTree tree)
{
    if (tree)
    {
        printf("%d  ",tree->key);
        preorder_splaytree(tree->left);
        preorder_splaytree(tree->right);
    }
}

//中序遍历伸展树
void inorder_splaytree(SplayTree tree)
{
    if (tree)
    {
        inorder_splaytree(tree->left);
        printf("%d  ",tree->key);
        inorder_splaytree(tree->right);
    }
}

//后序遍历伸展树
void poster_splaytree(SplayTree tree)
{
    if (tree)
    {
        poster_splaytree(tree->left);
        poster_splaytree(tree->right);
        printf("%d  ", tree->key);
    }
}

3. 查找给的关键值key的节点

//(递归实现)查找伸展树中键值为key的节点
Node *splaytree_search(SplayTree x, Type key)
{
    if(x == NULL || x->key == key)
        return x;
    if(key < x->key)
        return splaytree_search(x->left, key);
    if(key > x->key)
        return splaytree_search(x->right, key);
}

//(非递归实现）查找伸展树中键值为key的节点
Node *iterative_splaytree_search(SplayTree x, Type key)
{
    while ((x!= NULL)&&(x->key != key))
    {
        if(key < x->key)
            x = x->left;
        else 
            x = x->right;
    }
    return x;
}

4.查找伸展树中的最小关键值、最大关键值的节点

//查找最小节点：返回tree为根节点的伸展树的最小节点
Node *splaytree_minimum(SplayTree tree)
{
    if (tree == NULL)
    {
        printf("splay tree is empty!\n");
        return NULL;
    }
    while (tree->left != NULL)
        tree = tree->left;
    return tree;    
}

//查找最大节点：返回tree为根节点的伸展树的最大节点
Node *splaytree_maximum(SplayTree tree)
{
    if (tree == NULL)
    {
        printf("splay tree is empty!\n");
        return NULL;
    }
    while (tree->right != NULL)
        tree = tree->right;
    return tree;
}

5.伸展树的旋转

旋转key对应的节点为根节点

注意：
（a）伸展树中存在键值为key的节点， 将该节点旋转为根节点

（b）伸展树中不存在键值为key的节点，并且key < tree->key.

b-1:键值为key的节点的前驱节点存在的话，将前驱节点旋转为根节点

b-2:键值为key的节点存在前驱节点的话，则意味着，key比树中任何键值都小，那么此时，将最小节点旋转为根节点

(c): 伸展树中不存在键值为key的节点，并且key > tree->key。

c-1:键值为key的节点的后继节点存在的话，将后继节点旋转为根节点

c-2:键值为key的后继节点存在的话，则意味着，key比树中任何键值都打，那么此时，将最大节点旋转为根节点。

Node *splaytree_splay(SplayTree tree, Type key)
{
    Node N, *l, *r, *c;
    if(tree == NULL)
        return NULL;
    N.left = N.right = NULL;
    l = r = &N;

    for (;;)
    {
        if (key < tree->key)
        {
            if(tree->left == NULL)
                break;
            if (key < tree->left->key)  //01,rotate right
            {
                c = tree->left;
                tree->left = c->right;
                c->right = tree;
                tree = c;
                if(tree->left == NULL)
                    break;
            }
            r->left = tree;     //02,link right
            r = tree;
            tree = tree->left;
        }
        else if(key > tree->key)
        {
            if(tree->right == NULL)
                break;
            if(key > tree->right->key)      //03,rotate left
            {
                c = tree->right;
                tree->right = c->left;
                c->left = tree;
                tree = c;
                if(tree->right == NULL)
                    break;
            }
            l->right = tree;        //04,link left
            l = tree;
            tree = tree->right;
        }
        else break;
    }

    l->right = tree->left;      //05, assemble
    r->left = tree->right;
    tree->left = N.right;
    tree->right = N.left;

    return tree;
}

6.插入节点

//将节点插入到伸展树中(不旋转)，并返回根节点
Node *splaytree_insert(SplayTree tree, Node *z)
{
    Node *y = NULL;
    Node *x = tree;

    //查找z的插入位置
    while (x != NULL)
    {
        y = x;
        if(z->key < x->key)
            x = x->left;
        else if(z->key > x ->key)
            x = x->right;
        else
        {
            printf("节点已经存在！\n");
            free(z);
            return tree;
        }
    }

    if(y == NULL)
        tree = z;
    else if(z->key < y->key)
        y->left = z;
    else 
        y->right = z;
    return tree;
}

7.创建伸展树节点

//创建并返回伸展树节点
//key：键值，parent:父节点， left：左孩子，right：右孩子
static Node *create_spalytree_node(Type key, Node *left, Node *right)
{
    Node *p;
    p = (Node *)malloc(sizeof(Node));
    if(p == NULL)
    {
        printf("out of space!\n");
        return NULL;
    }

    p->key = key;
    p->left =   left;
    p->right = right;

    return p;
}

8.创建节点key，并旋转为根节点

//新建节点key，并将其插入到伸展树中，将插入节点旋转为根节点
Node *insert_splaytree(SplayTree tree, Type key)
{
    Node *z; //新建节点

    if((z = create_spalytree_node(key, NULL, NULL))== NULL) //新建节点失败，则返回
        return tree;

    //插入节点
    tree = splaytree_insert(tree, z);

    //将节点key旋转为根节点
    tree = splaytree_splay(tree, key);
}

9.删除key节点

//删除key节点，返回根节点(根节点是被删除节点的前驱节点)
Node *delete_splaytree(SplayTree tree, Type key)
{
    Node *x;
    if(tree == NULL)
        return NULL;
    //查找键值为key的节点，找不到的话直接返回
    if(splaytree_search(tree,key) == NULL)
        return tree;

    //将key对应的节点旋转为根节点
    tree = splaytree_splay(tree, key);

    if (tree->left)
    {
        //将tree的前驱节点旋转为根节点
        x = splaytree_splay(tree->left, key);

        //移除tree节点
        x->right = tree->right;
    }
    else 
        x = tree->right;

    free(tree);
    return x;
}

其实伸展树的大部分操作还是二叉树的操作，只是在访问节点时，将节点旋转至跟节点，留意该旋转操作。

完整的测试代码

#include <stdio.h>
#include <stdlib.h>
typedef int Type;

typedef struct SplayTreeNode
{
    Type key;  //关键字
    struct SplayTreeNode *left;  //左子树
    struct SplayTreeNode *right; //右子树
}Node, *SplayTree;

//前序遍历伸展树
void preorder_splaytree(SplayTree tree)
{
    if (tree)
    {
        printf("%d  ",tree->key);
        preorder_splaytree(tree->left);
        preorder_splaytree(tree->right);
    }
}

//中序遍历伸展树
void inorder_splaytree(SplayTree tree)
{
    if (tree)
    {
        inorder_splaytree(tree->left);
        printf("%d  ",tree->key);
        inorder_splaytree(tree->right);
    }
}

//后序遍历伸展树
void poster_splaytree(SplayTree tree)
{
    if (tree)
    {
        poster_splaytree(tree->left);
        poster_splaytree(tree->right);
        printf("%d  ", tree->key);
    }
}


//(递归实现)查找伸展树中键值为key的节点
Node *splaytree_search(SplayTree x, Type key)
{
    if(x == NULL || x->key == key)
        return x;
    if(key < x->key)
        return splaytree_search(x->left, key);
    if(key > x->key)
        return splaytree_search(x->right, key);
}

//(非递归实现）查找伸展树中键值为key的节点
Node *iterative_splaytree_search(SplayTree x, Type key)
{
    while ((x!= NULL)&&(x->key != key))
    {
        if(key < x->key)
            x = x->left;
        else 
            x = x->right;
    }
    return x;
}

//查找最小节点：返回tree为根节点的伸展树的最小节点
Node *splaytree_minimum(SplayTree tree)
{
    if (tree == NULL)
    {
        printf("splay tree is empty!\n");
        return NULL;
    }
    while (tree->left != NULL)
        tree = tree->left;
    return tree;    
}

//查找最大节点：返回tree为根节点的伸展树的最大节点
Node *splaytree_maximum(SplayTree tree)
{
    if (tree == NULL)
    {
        printf("splay tree is empty!\n");
        return NULL;
    }
    while (tree->right != NULL)
        tree = tree->right;
    return tree;
}


//旋转key对应的节点为根节点
//注意：（a）伸展树中存在键值为key的节点， 将该节点旋转为根节点
//（b）伸展树中不存在键值为key的节点，并且key < tree->key.
//      b-1:键值为key的节点的前驱节点存在的话，将前驱节点旋转为根节点
//      b-2:键值为key的节点存在前驱节点的话，则意味着，key比树中任何键值都小，那么此时，将最小节点旋转为根节点
//(c): 伸展树中不存在键值为key的节点，并且key > tree->key。
//      c-1:键值为key的节点的后继节点存在的话，将后继节点旋转为根节点
//      c-2:键值为key的后继节点存在的话，则意味着，key比树中任何键值都打，那么此时，将最大节点旋转为根节点。
Node *splaytree_splay(SplayTree tree, Type key)
{
    Node N, *l, *r, *c;
    if(tree == NULL)
        return NULL;
    N.left = N.right = NULL;
    l = r = &N;

    for (;;)
    {
        if (key < tree->key)
        {
            if(tree->left == NULL)
                break;
            if (key < tree->left->key)  //01,rotate right
            {
                c = tree->left;
                tree->left = c->right;
                c->right = tree;
                tree = c;
                if(tree->left == NULL)
                    break;
            }
            r->left = tree;     //02,link right
            r = tree;
            tree = tree->left;
        }
        else if(key > tree->key)
        {
            if(tree->right == NULL)
                break;
            if(key > tree->right->key)      //03,rotate left
            {
                c = tree->right;
                tree->right = c->left;
                c->left = tree;
                tree = c;
                if(tree->right == NULL)
                    break;
            }
            l->right = tree;        //04,link left
            l = tree;
            tree = tree->right;
        }
        else break;
    }

    l->right = tree->left;      //05, assemble
    r->left = tree->right;
    tree->left = N.right;
    tree->right = N.left;

    return tree;
}

//将节点插入到伸展树中(不旋转)，并返回根节点
Node *splaytree_insert(SplayTree tree, Node *z)
{
    Node *y = NULL;
    Node *x = tree;

    //查找z的插入位置
    while (x != NULL)
    {
        y = x;
        if(z->key < x->key)
            x = x->left;
        else if(z->key > x ->key)
            x = x->right;
        else
        {
            printf("节点已经存在！\n");
            free(z);
            return tree;
        }
    }

    if(y == NULL)
        tree = z;
    else if(z->key < y->key)
        y->left = z;
    else 
        y->right = z;
    return tree;
}

//创建并返回伸展树节点
//key：键值，parent:父节点， left：左孩子，right：右孩子
static Node *create_spalytree_node(Type key, Node *left, Node *right)
{
    Node *p;
    p = (Node *)malloc(sizeof(Node));
    if(p == NULL)
    {
        printf("out of space!\n");
        return NULL;
    }

    p->key = key;
    p->left =   left;
    p->right = right;

    return p;
}


//新建节点key，并将其插入到伸展树中，将插入节点旋转为根节点
Node *insert_splaytree(SplayTree tree, Type key)
{
    Node *z; //新建节点

    if((z = create_spalytree_node(key, NULL, NULL))== NULL) //新建节点失败，则返回
        return tree;

    //插入节点
    tree = splaytree_insert(tree, z);

    //将节点key旋转为根节点
    tree = splaytree_splay(tree, key);
}


//删除key节点，返回根节点(根节点是被删除节点的前驱节点)
Node *delete_splaytree(SplayTree tree, Type key)
{
    Node *x;
    if(tree == NULL)
        return NULL;
    //查找键值为key的节点，找不到的话直接返回
    if(splaytree_search(tree,key) == NULL)
        return tree;

    //将key对应的节点旋转为根节点
    tree = splaytree_splay(tree, key);

    if (tree->left)
    {
        //将tree的前驱节点旋转为根节点
        x = splaytree_splay(tree->left, key);

        //移除tree节点
        x->right = tree->right;
    }
    else 
        x = tree->right;

    free(tree);
    return x;
}

//销毁伸展树
void destroy_splaytree(SplayTree tree)
{
    if(tree == NULL)
        return ;
    if(tree->left != NULL)
        destroy_splaytree(tree->left);
    if(tree->right != NULL)
        destroy_splaytree(tree->right);
    free(tree);
}

//打印伸展树
void print_splaytree(SplayTree tree, Type key, int direction)
{
    if (tree)
    {
        if(direction == 0) //tree是根节点
            printf("%2d is root\n", tree->key);
        else 
            printf("%2d is %2d's %6s child\n", tree->key, key, direction == 1?"right" :"left");

        print_splaytree(tree->left, tree->key, -1);
        print_splaytree(tree->right, tree->key, 1);
    }
}



 //测试
 int main()
 {
     int a[] = {10, 50, 40, 30, 20, 60};
     int i;

     SplayTree root = NULL;
     printf("===依次添加===\n");
     for (i = 0; i < 6; i ++)
     {
         printf("%d  ", a[i]);
         root = insert_splaytree(root, a[i]);
     }

     printf("\n 前序遍历\n");
     preorder_splaytree(root);

     printf("\n中序遍历\n");
     inorder_splaytree(root);

     printf("\n后续遍历\n");
     poster_splaytree(root);

     printf("\n最大值：%d\n",splaytree_maximum(root)->key);

     printf("最小值：%d\n",splaytree_minimum(root)->key);

     printf("树的详细信息：\n");
     print_splaytree(root, root->key, 0);

     i = 30;
     printf("旋转节点为%d为根节点\n", i);
     root = splaytree_splay(root, i);
     printf("树的详细信息\n");
     print_splaytree(root, root->key, 0);

     destroy_splaytree(root);

     system("pause");
     return 0;
 }

这里写图片描述

reference：http://www.cnblogs.com/skywang12345/p/3604238.html?utm_source=tuicool

Luts
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
感知机与多层网络
源编程之美，达万物之理
07-26 5764
[toc] 之前做车牌识别的时候，在字符识别（OCR）时，使用的是人工神经网络（ANN），这里总结介绍一下人工神经的相关知识。1.神经网络1.1 定义人工神经网络（ANN）又称神经网络（NN），是一种模拟人脑的学习系统的生物模型。神经网络的由大量相互连结的节点构成一个复杂的网络结构，每个节点都有多个输入和一个输出，并且每个输入对应有一个权重因子，节点的输出就是所有这些输入与权重乘积的耦合。 通俗
车牌检测--master opencv
源编程之美，达万物之理
04-19 2957
自动车牌识别（Automatic Number Plate Recognition,ANPR),使用一种光学字符识别（O菩提差了Character Recognition, OCR)和其他方法（如图像分割与检测）来获取车辆牌照的监控方法。 对于一个ANPR系统，最好的是使用一个红外（IR）摄像机来获得车辆牌照，因为在分割这一步，对检测和OCR分割很简单、干净，误差小。这由光学的一下基本原理决定的。
伸展树 Splay Tree
一代键客的博客
08-14 144
在二叉搜索树的基础上加了每次访问的节点都会变为根节点 伸展树 JAVA 实现 1、节点定义 private static class SplayTreeNode&lt;T extends Comparable&lt;T&gt;&gt; { private T element; private SplayTreeNode&lt;T&gt; leftNode; private S...
数据结构 - 伸展树 Splay Tree
爱吃柚子的好奶罐
02-23 646
目录 一、什么是伸展树？ 二、Splay操作的设计模式 三、旋转操作讨论 四、删除操作 五、完整程序 一、什么是伸展树？ 80-20黄金法则显示，日常中我们80%的访问发生在20%的数据上。 如果我们能够把经常访问的节点推到靠近根节点的位置，那么就可以极大的提高访问速度。 这就是伸展树的出发点，并实现了以下方案：每次查找节点之后对树进行重构（旋转操作），把被查找的节点搬移到树根。 与二叉...
伸展树 splay tree
jollyjumper的专栏
05-15 734
伸展树因为实现简单，均摊性能好，使用空间少,在竞赛中广为使用。 转自: http://blog.csdn.net/changtao381/article/details/8936765 另一篇介绍性的文章是 杨思雨 - 伸展树的基本操作与应用 http://www.docin.com/p-63165342.html 类别：二叉排序树 空间效率：O(
伸展树splay tree
shidongxing的专栏
11-28 240
保证从空树开始任意连续M次操作最多花费O（MlogN）的时间， 每次操作的摊还代价是O(logN)基本想法是：当一个节点被访问以后，它就要经过一系列AVL树的旋转被放到根上 因为在很多系统中，当一个节点被访问时，它就很可能不久后再次被访问到
数据结构伸展树splay.rar
07-16
伸展树（Splay Tree），也叫分裂树，是一种二叉排序树，它能在O(log n)内完成插入、查找和删除操作。它由丹尼尔·斯立特Daniel Sleator 和 罗伯特·恩卓·塔扬Robert Endre Tarjan 在1985年发明的。 [1] 在伸展树上...
splaytree.zip
04-23
展树（Splay Tree）是一种二叉搜索树，它能在O(log n)内完成插入、查找和删除操作。它由Daniel Sleator和Robert Tarjan创造。它的优势在于不需要记录用于平衡树的冗余信息。在伸展树上的一般操作都基于伸展操作。
C++伸展树实现.zip
08-20
C++伸展树实现
伸展树(Splay tree)图解与实现(2020.10.22).pdf
10-26
伸展树(Splay tree)图解与实现(2020.10.22).pdf
伸展树(Splay Tree)
12-17
伸展树（Splay Tree）是一种二叉排序树，它能在O(log n)内完成插入、查找和删除操作。它由Daniel Sleator和Robert Tarjan创造。它的优势在于不需要记录用于平衡树的冗余信息。在伸展树上的一般操作都基于伸展操作。
谷歌图片搜索
源编程之美，达万物之理
06-06 1266
对于像谷歌、百度识图这种图像搜索的算法，主要有三个步骤： 将目标图片进行特征提取，描述图像的算法很多，用的比较多的是：SIFT描述子，指纹算法函数，bundling features算法，hash function（散列函数）等。也可以根据不同的图像，设计不同的算法，比如图像局部N阶矩的方法提取图像特征。 将图像特征信息进行编码，并将海量图像编码做查找表。对于目标图像，可以对分辨率较大的图像进行降采
栈 ADT 结构
源编程之美，达万物之理
04-30 591
栈（stack）是限制插入与删除只能在一个位置上进行的表，该位置叫做栈的顶（top）。栈的基本操作包括进栈（push）即插入、出栈（pop）即删除。不允许对空栈进行pop操作。栈与队列不同，队列是先进先出（FIFO），栈是后进先出（LIFO），就是说只有栈顶的元素是可以被访问的。与队列相似，栈也可以通过链表或者数组的形式实现。在单链表的顶端插入可以实现push，删除顶端元素实现pop，Top操作考察
最大子序列的和问题
源编程之美，达万物之理
07-21 557
问题描述：给出一个整数数组：a1, a2, a3, … … an;求最大的子序列和（如果数组都为负数，则为0）方法1：遍历求解 从数组的首元素a1开始遍历，一直累加ak，求出最大值。maxsum: 要求的最大子序列和， tempsum: a[i]+a[i+1]+a[i+2]+…+a[n-1];(0<=1//O(N^2) int maxfun(int a[], int n) {
AVL树
源编程之美，达万物之理
05-13 534
AVL树 破坏平衡的四种情况 LL旋转 RR旋转 LR旋转 RL旋转 AVL树的基本操作 测试范例AVL树AVL树是带有平衡条件的二叉查找树，最简单的定义为：一颗AVL树是其每个节点的左子树和右子树的高度最多相差1的二叉查找树。C语言定义：struct AvlNode; typedef struct AvlNode *position; typedef struct AvlNode *avlTree
二叉查找树 ADT
源编程之美，达万物之理
05-02 522
二叉树是每个节点最多有两个子树的数结构，即左子树、右子树。二叉树的第i层至多有2^（i-1)个节点，深度为k的二叉树至多有(2^k） - 1个节点。二叉查找树：对于树中的每个节点X，他的左子树中所有关键字值小于X的关键字值，而它的右子树中所有关键字值大于X的关键字值。二叉搜索树可以方便的实现搜索算法。在搜索元素x的时候，我们可以将x和根节点比较: 如果x等于根节点，那么找到x，停止搜索 (终止条件)
队列的基本操作
源编程之美，达万物之理
04-25 503
队列是链表的一种形式，队列具有先进先出（FIFO）的特性，即使用队列时，插入在一端进行，而删除在另一端进行。队列的基本操作是Enqueue（入队），他是在表的末尾（rear）插入一个元素，还有Dequequ（出队），即删除（或返回）在表的开头（队头，front）的元素。队列可以使用链表或者数组来实现。基本的操作示例如下：链表实现：#include <stdlib.h> #include <stdio
数
源编程之美，达万物之理
04-30 497
一颗树是一些节点的集合，这些集合可以是 空集；若非空，则一颗树由称作根（root）的节点r以及0个或多个非空的字数T1， T2， T3， …, Tk组成，这些子树中的每一颗的根都有来自根r的一条有向边（edge）所连接。每一颗子树的根叫做跟r的儿子（child），而r是每一颗子树的根的父亲（parent）。一颗具体的树：1.树的相关术语节点的度：一个节点含有的子树的个数称为该节点的度；树的度：一棵树
帮我生成一段splay平衡树代码
最新发布
05-28
class SplayTree { private: Node *root; void left_rotate(Node *x) { Node *y = x->right; x->right = y->left; if (y->left != nullptr) { y->left->p = x; } y->p = x->p; if (x->p == nullptr) { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值