6天通吃树结构—— 第三天 Treap树

最新推荐文章于 2024-01-23 06:00:00 发布
转载 最新推荐文章于 2024-01-23 06:00:00 发布 · 86 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://yq.aliyun.com/articles/27551
文章标签：

#数据结构与算法

本文介绍了一种结合二叉查找树和堆性质的数据结构——Treap树。通过在每个节点维护一个随机优先级来保证树的高度接近对数级别，从而提高了树的效率。文章详细讲解了Treap树的基本操作，如添加、删除等，并提供了实现代码。

       我们知道，二叉查找树相对来说比较容易形成最坏的链表情况，所以前辈们想尽了各种优化策略，包括AVL，红黑，以及今天

要讲的Treap树。

       Treap树算是一种简单的优化策略，这名字大家也能猜到，树和堆的合体，其实原理比较简单，在树中维护一个"优先级“，”优先级“

采用随机数的方法，但是”优先级“必须满足根堆的性质，当然是“大根堆”或者“小根堆”都无所谓，比如下面的一棵树：

从树中我们可以看到：

①：节点中的key满足“二叉查找树”。

②：节点中的“优先级”满足小根堆。

 

一：基本操作

1：定义

#region Treap树节点
    /// <summary>
    /// Treap树
    /// </summary>
    /// <typeparam name="K"></typeparam>
    /// <typeparam name="V"></typeparam>
    public class TreapNode<K, V>
    {
        /// <summary>
        /// 节点元素
        /// </summary>
        public K key;

        /// <summary>
        /// 优先级（采用随机数）
        /// </summary>
        public int priority;

        /// <summary>
        /// 节点中的附加值
        /// </summary>
        public HashSet<V> attach = new HashSet<V>();

        /// <summary>
        /// 左节点
        /// </summary>
        public TreapNode<K, V> left;

        /// <summary>
        /// 右节点
        /// </summary>
        public TreapNode<K, V> right;

        public TreapNode() { }

        public TreapNode(K key, V value, TreapNode<K, V> left, TreapNode<K, V> right)
        {
            //KV键值对
            this.key = key;
            this.priority = new Random(DateTime.Now.Millisecond).Next(0,int.MaxValue);
            this.attach.Add(value);

            this.left = left;
            this.right = right;
        }
    }
    #endregion

节点里面定义了一个priority作为“堆定义”的旋转因子，因子采用“随机数“。

 

2：添加

    首先我们知道各个节点的“优先级”是采用随机数的方法，那么就存在一个问题，当我们插入一个节点后，优先级不满足“堆定义"的

时候我们该怎么办，前辈说此时需要旋转，直到满足堆定义为止。

旋转有两种方式，如果大家玩转了AVL，那么对Treap中的旋转的理解轻而易举。

①： 左左情况旋转

从图中可以看出，当我们插入“节点12”的时候，此时“堆性质”遭到破坏，必须进行旋转，我们发现优先级是6<9，所以就要进行

左左情况旋转，最终也就形成了我们需要的结果。

 

②： 右右情况旋转

既然理解了”左左情况旋转“，右右情况也是同样的道理，优先级中发现“6<9"，进行”右右旋转“最终达到我们要的效果。

#region 添加操作
        /// <summary>
        /// 添加操作
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public void Add(K key, V value)
        {
            node = Add(key, value, node);
        }
        #endregion

        #region 添加操作
        /// <summary>
        /// 添加操作
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="tree"></param>
        /// <returns></returns>
        public TreapNode<K, V> Add(K key, V value, TreapNode<K, V> tree)
        {
            if (tree == null)
                tree = new TreapNode<K, V>(key, value, null, null);

            //左子树
            if (key.CompareTo(tree.key) < 0)
            {
                tree.left = Add(key, value, tree.left);

                //根据小根堆性质，需要”左左情况旋转”
                if (tree.left.priority < tree.priority)
                {
                    tree = RotateLL(tree);
                }
            }

            //右子树
            if (key.CompareTo(tree.key) > 0)
            {
                tree.right = Add(key, value, tree.right);

                //根据小根堆性质，需要”右右情况旋转”
                if (tree.right.priority < tree.priority)
                {
                    tree = RotateRR(tree);
                }
            }

            //将value追加到附加值中（也可对应重复元素）
            if (key.CompareTo(tree.key) == 0)
                tree.attach.Add(value);

            return tree;
        }
        #endregion

3:删除

  跟普通的二叉查找树一样，删除结点存在三种情况。

①：叶子结点

      跟普通查找树一样，直接释放本节点即可。

②：单孩子结点

     跟普通查找树一样操作。

③：满孩子结点

    其实在treap中删除满孩子结点有两种方式。

第一种：跟普通的二叉查找树一样，找到“右子树”的最左结点（15），拷贝元素的值，但不拷贝元素的优先级，然后在右子树中

           删除“结点15”即可，最终效果如下图。

第二种：将”结点下旋“，直到该节点不是”满孩子的情况“，该赋null的赋null，该将孩子结点顶上的就顶上，如下图：

当然从理论上来说，第二种删除方法更合理，这里我写的就是第二种情况的代码。

#region 删除当前树中的节点
        /// <summary>
        /// 删除当前树中的节点
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public void Remove(K key, V value)
        {
            node = Remove(key, value, node);
        }
        #endregion

        #region 删除当前树中的节点
        /// <summary>
        /// 删除当前树中的节点
        /// </summary>
        /// <param name="key"></param>
        /// <param name="tree"></param>
        /// <returns></returns>
        public TreapNode<K, V> Remove(K key, V value, TreapNode<K, V> tree)
        {
            if (tree == null)
                return null;

            //左子树
            if (key.CompareTo(tree.key) < 0)
            {
                tree.left = Remove(key, value, tree.left);
            }
            //右子树
            if (key.CompareTo(tree.key) > 0)
            {
                tree.right = Remove(key, value, tree.right);
            }
            /*相等的情况*/
            if (key.CompareTo(tree.key) == 0)
            {
                //判断里面的HashSet是否有多值
                if (tree.attach.Count > 1)
                {
                    //实现惰性删除
                    tree.attach.Remove(value);
                }
                else
                {
                    //有两个孩子的情况
                    if (tree.left != null && tree.right != null)
                    {
                        //如果左孩子的优先级低就需要“左旋”
                        if (tree.left.priority < tree.right.priority)
                        {
                            tree = RotateLL(tree);
                        }
                        else
                        {
                            //否则“右旋”
                            tree = RotateRR(tree);
                        }

                        //继续旋转
                        tree = Remove(key, value, tree);
                    }
                    else
                    {
                        //如果旋转后已经变成了叶子节点则直接删除
                        if (tree == null)
                            return null;

                        //最后就是单支树
                        tree = tree.left == null ? tree.right : tree.left;
                    }
                }
            }

            return tree;
        }
        #endregion

4:总结

treap树在CURD中是期望的logN，由于我们加了”优先级“,所以会出现”链表“的情况几乎不存在，但是他的Add和Remove相比严格的

平衡二叉树有更少的旋转操作，可以说性能是在”普通二叉树“和”平衡二叉树“之间。

最后是总运行代码，不过这里我就不做测试了。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DataStruct
{
    #region Treap树节点
    /// <summary>
    /// Treap树
    /// </summary>
    /// <typeparam name="K"></typeparam>
    /// <typeparam name="V"></typeparam>
    public class TreapNode<K, V>
    {
        /// <summary>
        /// 节点元素
        /// </summary>
        public K key;

        /// <summary>
        /// 优先级（采用随机数）
        /// </summary>
        public int priority;

        /// <summary>
        /// 节点中的附加值
        /// </summary>
        public HashSet<V> attach = new HashSet<V>();

        /// <summary>
        /// 左节点
        /// </summary>
        public TreapNode<K, V> left;

        /// <summary>
        /// 右节点
        /// </summary>
        public TreapNode<K, V> right;

        public TreapNode() { }

        public TreapNode(K key, V value, TreapNode<K, V> left, TreapNode<K, V> right)
        {
            //KV键值对
            this.key = key;
            this.priority = new Random(DateTime.Now.Millisecond).Next(0,int.MaxValue);
            this.attach.Add(value);

            this.left = left;
            this.right = right;
        }
    }
    #endregion

    public class TreapTree<K, V> where K : IComparable
    {
        public TreapNode<K, V> node = null;

        #region 添加操作
        /// <summary>
        /// 添加操作
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public void Add(K key, V value)
        {
            node = Add(key, value, node);
        }
        #endregion

        #region 添加操作
        /// <summary>
        /// 添加操作
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="tree"></param>
        /// <returns></returns>
        public TreapNode<K, V> Add(K key, V value, TreapNode<K, V> tree)
        {
            if (tree == null)
                tree = new TreapNode<K, V>(key, value, null, null);

            //左子树
            if (key.CompareTo(tree.key) < 0)
            {
                tree.left = Add(key, value, tree.left);

                //根据小根堆性质，需要”左左情况旋转”
                if (tree.left.priority < tree.priority)
                {
                    tree = RotateLL(tree);
                }
            }

            //右子树
            if (key.CompareTo(tree.key) > 0)
            {
                tree.right = Add(key, value, tree.right);

                //根据小根堆性质，需要”右右情况旋转”
                if (tree.right.priority < tree.priority)
                {
                    tree = RotateRR(tree);
                }
            }

            //将value追加到附加值中（也可对应重复元素）
            if (key.CompareTo(tree.key) == 0)
                tree.attach.Add(value);

            return tree;
        }
        #endregion

        #region 第一种：左左旋转（单旋转）
        /// <summary>
        /// 第一种：左左旋转（单旋转）
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        public TreapNode<K, V> RotateLL(TreapNode<K, V> node)
        {
            //top：需要作为顶级节点的元素
            var top = node.left;

            //先截断当前节点的左孩子
            node.left = top.right;

            //将当前节点作为temp的右孩子
            top.right = node;

            return top;
        }
        #endregion

        #region 第二种：右右旋转（单旋转）
        /// <summary>
        /// 第二种：右右旋转（单旋转）
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        public TreapNode<K, V> RotateRR(TreapNode<K, V> node)
        {
            //top：需要作为顶级节点的元素
            var top = node.right;

            //先截断当前节点的右孩子
            node.right = top.left;

            //将当前节点作为temp的右孩子
            top.left = node;

            return top;
        }
        #endregion

        #region 树的指定范围查找
        /// <summary>
        /// 树的指定范围查找
        /// </summary>
        /// <param name="min"></param>
        /// <param name="max"></param>
        /// <returns></returns>
        public HashSet<V> SearchRange(K min, K max)
        {
            HashSet<V> hashSet = new HashSet<V>();

            hashSet = SearchRange(min, max, hashSet, node);

            return hashSet;
        }
        #endregion

        #region 树的指定范围查找
        /// <summary>
        /// 树的指定范围查找
        /// </summary>
        /// <param name="range1"></param>
        /// <param name="range2"></param>
        /// <param name="tree"></param>
        /// <returns></returns>
        public HashSet<V> SearchRange(K min, K max, HashSet<V> hashSet, TreapNode<K, V> tree)
        {
            if (tree == null)
                return hashSet;

            //遍历左子树（寻找下界）
            if (min.CompareTo(tree.key) < 0)
                SearchRange(min, max, hashSet, tree.left);

            //当前节点是否在选定范围内
            if (min.CompareTo(tree.key) <= 0 && max.CompareTo(tree.key) >= 0)
            {
                //等于这种情况
                foreach (var item in tree.attach)
                    hashSet.Add(item);
            }

            //遍历右子树（两种情况：①:找min的下限 ②：必须在Max范围之内）
            if (min.CompareTo(tree.key) > 0 || max.CompareTo(tree.key) > 0)
                SearchRange(min, max, hashSet, tree.right);

            return hashSet;
        }
        #endregion

        #region 找到当前树的最小节点
        /// <summary>
        /// 找到当前树的最小节点
        /// </summary>
        /// <returns></returns>
        public TreapNode<K, V> FindMin()
        {
            return FindMin(node);
        }
        #endregion

        #region 找到当前树的最小节点
        /// <summary>
        /// 找到当前树的最小节点
        /// </summary>
        /// <param name="tree"></param>
        /// <returns></returns>
        public TreapNode<K, V> FindMin(TreapNode<K, V> tree)
        {
            if (tree == null)
                return null;

            if (tree.left == null)
                return tree;

            return FindMin(tree.left);
        }
        #endregion

        #region 找到当前树的最大节点
        /// <summary>
        /// 找到当前树的最大节点
        /// </summary>
        /// <returns></returns>
        public TreapNode<K, V> FindMax()
        {
            return FindMin(node);
        }
        #endregion

        #region 找到当前树的最大节点
        /// <summary>
        /// 找到当前树的最大节点
        /// </summary>
        /// <param name="tree"></param>
        /// <returns></returns>
        public TreapNode<K, V> FindMax(TreapNode<K, V> tree)
        {
            if (tree == null)
                return null;

            if (tree.right == null)
                return tree;

            return FindMax(tree.right);
        }
        #endregion

        #region 删除当前树中的节点
        /// <summary>
        /// 删除当前树中的节点
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public void Remove(K key, V value)
        {
            node = Remove(key, value, node);
        }
        #endregion

        #region 删除当前树中的节点
        /// <summary>
        /// 删除当前树中的节点
        /// </summary>
        /// <param name="key"></param>
        /// <param name="tree"></param>
        /// <returns></returns>
        public TreapNode<K, V> Remove(K key, V value, TreapNode<K, V> tree)
        {
            if (tree == null)
                return null;

            //左子树
            if (key.CompareTo(tree.key) < 0)
            {
                tree.left = Remove(key, value, tree.left);
            }
            //右子树
            if (key.CompareTo(tree.key) > 0)
            {
                tree.right = Remove(key, value, tree.right);
            }
            /*相等的情况*/
            if (key.CompareTo(tree.key) == 0)
            {
                //判断里面的HashSet是否有多值
                if (tree.attach.Count > 1)
                {
                    //实现惰性删除
                    tree.attach.Remove(value);
                }
                else
                {
                    //有两个孩子的情况
                    if (tree.left != null && tree.right != null)
                    {
                        //如果左孩子的优先级低就需要“左旋”
                        if (tree.left.priority < tree.right.priority)
                        {
                            tree = RotateLL(tree);
                        }
                        else
                        {
                            //否则“右旋”
                            tree = RotateRR(tree);
                        }

                        //继续旋转
                        tree = Remove(key, value, tree);
                    }
                    else
                    {
                        //如果旋转后已经变成了叶子节点则直接删除
                        if (tree == null)
                            return null;

                        //最后就是单支树
                        tree = tree.left == null ? tree.right : tree.left;
                    }
                }
            }

            return tree;
        }
        #endregion
    }
}

Treap树模板 hdu-4585
Lee's blog
09-13 753
目录 例题：hdu 4585 Treap树 1、Treap树的唯一性 2、Treap树的平衡问题 3、Treap树的数据结构 4、Treap树的插入 5、插入过程中维护堆的过程中用到的旋转 6、寻找第k大的数 O(logn) 7、查询某个数的名次 O(logn) 8、hdu 4585 AC代码 例题：hdu 4585 Treap树 是一种简单的平衡二叉搜索...
偷懒专用平衡树——Treap
这是个博客
03-18 5474
Treap的实现
treap(树堆)
weixin_33923148的博客
05-06 191
一棵treap是一棵修改了结点顺序的二叉查找树，如图，显示一个例子，通常树内的每个结点x都有一个关键字值key[x]，另外，还要为结点分配priority[x]，它是一个独立选取的随机数。假设所有的优先级是不同的，所有的关键字也是不同的。treap的结点排列成让关键字遵循二叉查找树性质，并且优先级遵循最小堆顺序性质：1.如果v是u的左孩子，则key[v] &lt; key[u].2.如果v是u的右...
树和树结构(2) : Treap树
weixin_30530523的博客
12-27 145
测试题目来自 http://codevs.cn/problem/1164/ 部分内容来自网络 想要了解treap树，你先要知道什么是二叉搜索树。 二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则...
Treap树
qq_52237775的博客
10-09 236
简述： Treap=Tree+Heap。Treap树也是一个二叉搜索树，但是他多了一个键值key，这些优先级是是在结点插入时，随机赋予的，Treap根据这些优先级满足堆的性质。要满足堆的性质，treap树则构造了一个旋转函树。 对于treap树，基本的操作有：结点的定义，插入，旋转，找第k大的数，查询某个数 结点的定义： struct node{ int rank;//优先级 int key;//键值 int size;//这个结点为根结点时的子树的结点总数（用于名次数） n
并查集与高级数据结构——Treap树删除
"Treap树的删除-第5章高级数据结构(上) - 罗勇军 华东理工大学 数据结构 教材" 在高级数据结构中，Treap树是一种结合了二叉搜索树（BST）和堆特性的数据结构。它的主要优势在于通过随机化策略来保持树的平衡，从而...
动态序列与动态树问题——浅谈几种常用数据结构_莫凡.pdf
09-14
这些结构在应对序列区间查询、修改以及树结构动态变化时，能够提供高效的解决方案，对于深入理解数据结构和算法有着举足轻重的作用。 首先，线段树作为一种树形数据结构，被广泛应用于解决区间查询和修改问题。线段...
史上最简单的平衡树——无旋Treap.pdf
01-14
### 最简平衡树——无旋Treap（fhq_treap）详解 #### 一、简介 无旋Treap（fhq_treap），由范浩强发明，是一种高效的平衡树数据结构。它综合了Treap与Splay树的优点，支持常见的平衡树操作如插入、删除、查找等，...
第6章 平衡树Treap 测试数据.rar
12-02
http://ybt.ssoier.cn:8088 信息学奥赛一本通(提高篇)测试数据\第4部分 数据结构(提高篇)\ 第6章 平衡树Treap 测试数据
Treap 树
wodasini的专栏
12-22 390
Treap树堆 是一种 随机平衡二叉树。 相对于正正规规的AVL树，倒是灵活了许多。 Treap 也有旋转模式，但是只有单选转，而且Treap的旋转，怎么旋转，该不该旋转完全是随机化的，这样子在大大减少了编码量的同时，相对也把效率给提了上去。在最差情况下也比最差情况下的朴素 BST 好 代码参考 《Data Structure and Algorithm Analysis in C》
树：Treap树
——
06-23 777
我们知道，二叉查找树相对来说比较容易形成最坏的链表情况，所以前辈们想尽了各种优化策略，包括AVL，红黑，以及今天要讲的Treap树。 Treap树是什么？ treap是heap和tree结合，中文名叫树堆。 首先它每个节点有2个值value和weight，其中只看weight的话，满足heap二叉堆的特性(父亲比儿子都小/大)，只看value的话，满足排序二叉树特性(以左儿子为根的子树元
Treap树(堆树)
weixin_34354173的博客
07-23 235
描述 Treap=Tree+Heap（堆树）。 Treap 是一棵二叉搜索树 树的每个节点存储左指针和右指针，以及一个优先级，这个优先级是建树的时候随机制定的。 树的节点优先级满足堆序性质：任何节点的优先级必须至少和它的父节点的优先级一样大。 根节点的优先级最低。 这样的话，Treap是有一个随机附加域满足堆的性质的二叉搜索树，其结构相当于以随机数据插入的二叉搜索树。 Treap ADT...
树：Treaps
最新发布
新华编程特战队
01-23 1005
中完成，因为在每个节点上，人们可以根据比较删除树的一半，因此需要对数比较才能到达正确的节点（要添加或删除元素的位置）。函数在 BST 中搜索正确的位置，并在正确的位置添加节点，即根据 BST 和堆属性向右添加，并在添加后根据需要进行必要的旋转，对于旋转，将分别编写。（每个节点最多有 2 个子节点），这样左边的子节点存储的键小于根节点，右边的子节点存储的键大于根键，这对所有节点递归有效。是节点数，因为必须遍历路径中的所有节点才能到达正确的节点，在最坏的情况下可能是最后一个节点，例如，假设我们想在树中添加。
Treap 动态平衡树
cyclization的小栈
02-09 430
(注：本文是笔者在学习Treap的时候的一点收获，并将一些基础知识记录下来）Treap定义：treap是一中动态平衡的BST，可以高效地处理插入和删除等，是一棵有键值和优先值的树。 一些小笔记：（我刚学c++是很讨厌指针，但学到Treap时竟然可以接受了，O(∩_∩)O~~）初始定义struct node{ char *ch[2];//左右子树 int r;//随机的优先值
二叉树——Treap树（平衡树）
linglingnana的博客
10-24 1211
什么是树形结构 树形结构是一层次的嵌套结构。一个树形结构的外层和内层有相似的结构，所以这种结构可以递归的表示。经典数据结构中的各种树状图是一种典型的树形结构：一棵树可以简单地表示为根、左子树、右子树。左子树、右子树又有自己的子树。 什么是二叉搜索树（Binary Search Tree） 每个元素有自己的键值，这些键值能比较大小。通常把键值放在BST的节点上。任意一个节点的键值，比它左子树的所有键值都大，比它右子树的所有键值都小——中序遍历就可以得到它的有序排列。 树形结构的作用——这里主要讲二叉搜索树 数
二叉搜索树（BST）——Treap树
m0_56145255的博客
04-04 1398
文章目录Treap树Treap树的唯一性Treap树的平衡问题Treap树的插入Treap树的删除案例源码运行结果 Treap树 Treap树是一种比较简单的平衡二叉树。 Treap是一个合成词，把Tree和Heap各取一半组合而成。Treap是树和堆的结合，可以翻译成堆树。 二叉搜索树的每一个结点有一个键值，除此之外，Treap树为每一个结点还人为的添加了一个被称为优先级的权值。对于键值来说，这颗树是排序二叉树；对于优先级来说，这颗树是一个堆。堆的特征是：在这棵树的任意子树上，根结点的优先级最大。 Tr
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值