Day_25，数据结构扩张以红黑树为基础（将红黑树变更为区间树）

最新推荐文章于 2022-10-20 20:04:12 发布
最新推荐文章于 2022-10-20 20:04:12 发布
阅读量310 收藏 1
点赞数 1
分类专栏： 算法 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40301728/article/details/107147585
版权

将红黑树扩张为区间树
我们还是按照扩张数据结构的四个步骤走：
①红黑树为基础数据结构
②节点的key改为区间i；给节点新增一个max附加信息，max为以该节点为根的子树（包括自身）的最大端点值
③在基础数据结构的基础操作上（例如插入、删除）能否维护附加信息详看下面(1)(2)(3)(4)，其中(2)(3)(4)是对max的维护
④新增操作：获取树中是否有与给定区间重叠的区间

(1)区间树的创建：由之前的比较key改成比较i.low，即区间的左端点
下面三点是对max的维护
(2)插入：插入的时候仅需要维护插入节点node，以及node到根节点简单路径上的节点
(3)删除：根据上篇红黑树的删除可知，在删除过程中，会发生位置变动的就是 删除的节点 或者 删除节点的后继节点，因此维护也只需要维护这两个节点其中之一到根节点简单路径上的节点
(4)左右旋：通过观察下图可知，左右旋的过程中实际上只影响了x，y两个节点，因此只要维护这两个节点即可
在这里插入图片描述

上代码

下面仅列出有发生变化的函数以及新增的函数，其余部分查看上面文章
红黑树的实现及理解

#include <stdio.h>
#include <string.h>
#include <iostream>
using namespace std;

int Campare(int x,int y)
{
    if (x>y)
        return 1;
    else if (x==y)
        return 0;
    else
        return -1;
}

enum NodeColor
{
    RED = 1,
    BLACK = 2
};

template<class T>
class Interval
{
public:
    T low;
    T high;
    Interval(T x,T y)
    {
        int flag = Campare(x,y);
        if (flag ==1)
        {
            low = y;
            high = x;
        }
        else
        {
            low = x;
            high = y;
        }
    }
};

template<class T>
class RBTreeNode
{
public:
    Interval<T> *i;//区间
    T max;//该节点所在树的最大右端值
    RBTreeNode *left;//左孩子
    RBTreeNode *right;//右孩子
    RBTreeNode *p;//父亲
    NodeColor color;//颜色

    RBTreeNode()
    {
        i = NULL;
        max = NULL;
        left = NULL;
        right = NULL;
        p = NULL;
        color = NodeColor(BLACK);
    }
    RBTreeNode(Interval<T> *interval){
        i = interval;
        max = NULL;
        left = NULL;
        right = NULL;
        p = NULL;
        color = NodeColor(RED);
    }
    RBTreeNode(Interval<T> *interval,T maxValue,RBTreeNode * left,RBTreeNode *right,RBTreeNode *parent,NodeColor color){
        i = interval;
        max = maxValue;
        left = left;
        right = right;
        p = parent;
        color = color;
    }
    ~RBTreeNode(){
    }
};

template<class T>
class RBSearchTree
{
public:
    RBSearchTree();//创建空树
    RBSearchTree(RBTreeNode<T> a[]);//传入节点组创建树
    RBSearchTree(Interval<T> *a[],int length);//传入节点值组，创建树
    ~RBSearchTree();
    MidWalk();//中序遍历
    FrontWalk();//前序遍历
    BackWalk();//后序遍历
    RBTreeNode<T> * Search(Interval<T> *i);//找到第一个区间重合的的节点
    RBTreeNode<T> * Minimum();//树中最小节点
    RBTreeNode<T> * Maximum();//树中最大节点
    RBTreeNode<T> * TreePredecessor(RBTreeNode<T> *node);//某节点的前任 狗头.jpg  小于该节点的 值最大节点
    RBTreeNode<T> * TreeSuccessor(RBTreeNode<T> *node);//某节点的后驱             大于该节点的 值最小节点
    string Insert(Interval<T> *i);//插入
    string Delete(Interval<T> *i);//删除
private:
    RBTreeNode<T> *root;//根节点
    RBTreeNode<T> *NILNode;//叶节点（NIL节点）
    InitNILNode();//初始化NILNode
    MidWalkInner(RBTreeNode<T> *node);//中序遍历
    RBTreeInsertFix(RBTreeNode<T> *node);//插入时恢复红黑树性质
    RBTreeDeleteFix(RBTreeNode<T> *node);//删除时恢复红黑树性质
    RBTreeNode<T> * MinimumInner(RBTreeNode<T> *node);//树中最小节点
    RBTreeNode<T> * MaximumInner(RBTreeNode<T> *node);//树中最大节点
    RBTransplant(RBTreeNode<T> *pNode,RBTreeNode<T> *subNode);//单节点继承，subNode继承pNode原有的位置
    LeftRotate(RBTreeNode<T> *node);//左旋
    RightRotate(RBTreeNode<T> *node);//右旋
    CalMaxToRoot(RBTreeNode<T> *node);//计算max,插入节点和删除节点时都需要从当前节点一直往上推直到root
    CalMax(RBTreeNode<T> *node);
    string strTrue;//用于返回true的字符串
    string strFalse;//用于返回false的字符串
    string strNull;//用于返回null的字符串
};

template<class T>
RBSearchTree<T>::RBSearchTree()
{
    strTrue = "true";
    strFalse = "false";
    strNull = "null";
    InitNILNode();
}

template<class T>
RBSearchTree<T>::InitNILNode()
{
    RBTreeNode<T> *NILNode = new RBTreeNode<T>();
}

template<class T>
RBSearchTree<T>::RBSearchTree(RBTreeNode<T> a[])
{
    strTrue = "true";
    strFalse = "false";
    strNull = "null";
    InitNILNode();
}



template<class T>
RBSearchTree<T>::RBSearchTree(Interval<T> *a[],int length)
{
    strTrue = "true";
    strFalse = "false";
    strNull = "null";
    InitNILNode();
    //这里直接写成
    //root = new RBTreeNode<T>(a[0],NILNode,NILNode,NILNode,NodeColor(BLACK));
    //他在识别的时候 left!=right!=p 可能跟引用关系有关 改成&试试？？
    root = new RBTreeNode<T>(a[0]);
    root->p = NILNode;
    root->left = NILNode;
    root->right = NILNode;
    root->color = NodeColor(BLACK);
    //大体思路，循环遍历
      //小于找左孩子
      //大于找右孩子
      //孩子为空直接放置
      //如果i==0 将root指针指向该节点
    for (int i=1;i<length;i++)
    {
        Insert(a[i]);
    }
}


template<class T>
RBSearchTree<T>::MidWalk()
{
    RBTreeNode<T> *node = root;
    MidWalkInner(node);
    cout<<endl;
}

template<class T>
RBSearchTree<T>::MidWalkInner(RBTreeNode<T> *node)
{
    if (node!=NILNode)
    {
        MidWalkInner(node->left);
        cout<<"["<<node->i->low<<","<<node->i->high<<"]"<<" color is "<<node->color<<" p is "<<"["<<node->p->i->low<<","<<node->p->i->high<<"]"<<" max is "<<node->max<<endl;
        MidWalkInner(node->right);
    }
}

template<class T>
RBTreeNode<T> * RBSearchTree<T>::Search(Interval<T> *i)
{
    RBTreeNode<T> *node = root;
    while(node !=NILNode && (i->low > node->i->high || i->high < node->i->low))
    {
        if (node->left != NILNode && node->left->max >= i->low)
            node = node->left;
        else
            node = node->right;
    }
    return node;
}

template<class T>
RBTreeNode<T> *  RBSearchTree<T>::MinimumInner(RBTreeNode<T> *node)
{
    while(node->left!=NILNode)
        node = node->left;
    return node;
}

template<class T>
string RBSearchTree<T>::Insert(Interval<T> *i)
{
    RBTreeNode<T> *insertNode = new RBTreeNode<T>(i,NULL,NILNode,NILNode,NILNode,NodeColor(RED));
    RBTreeNode<T> *insertNodeParent = NILNode;
    RBTreeNode<T> *node = root;
    while(node != NILNode)
    {
        insertNodeParent = node;
        if (i->low <= node->i->low)
            node = node->left;
        else
            node = node->right;
    }
    insertNode->p = insertNodeParent;
    if (i->low <= insertNodeParent->i->low)
        insertNodeParent->left = insertNode;
    else
        insertNodeParent->right = insertNode;
    insertNode->left = NILNode;
    insertNode->right = NILNode;
    insertNode->color = NodeColor(RED);
    CalMaxToRoot(insertNode);
    RBTreeInsertFix(insertNode);
    return strTrue;
}


template<class T>
RBSearchTree<T>::RBTreeInsertFix(RBTreeNode<T> *node)
{
    while (node->p->color == NodeColor(RED))
    {
        if (node->p == node->p->p->left)
        {
            RBTreeNode<T> *y = node->p->p->right; //叔节点
            if (y->color == NodeColor(RED))
            {
                node->p->color = NodeColor(BLACK);
                node->p->p->color = NodeColor(RED);
                y->color = NodeColor(BLACK);
                node = node->p->p;
            }
            else if (node == node->p->right)
            {
                node = node->p;
                LeftRotate(node);
            }
            else
            {
                node->p->color = NodeColor(BLACK);
                node->p->p->color = NodeColor(RED);
                RightRotate(node->p->p);
            }
        }
        else
        {
            RBTreeNode<T> *y = node->p->p->left; //叔节点
            if (y->color == NodeColor(RED))
            {
                node->p->color = NodeColor(BLACK);
                node->p->p->color = NodeColor(RED);
                y->color = NodeColor(BLACK);
                node = node->p->p;
            }
            else if (node == node->p->left)
            {
                node = node->p;
                RightRotate(node);
            }
            else
            {
                node->p->color = NodeColor(BLACK);
                node->p->p->color = NodeColor(RED);
                LeftRotate(node->p->p);
            }
        }
    }
    root->color = NodeColor(BLACK);
}

template<class T>
RBTreeNode<T> *  RBSearchTree<T>::Maximum()
{
    RBTreeNode<T> *node = root;
    while(node->right!=NILNode)
        node = node->right;
    return node;
}

template<class T>
RBTreeNode<T> *  RBSearchTree<T>::MaximumInner(RBTreeNode<T> *node)
{
    while(node->right!=NILNode)
        node = node->right;
    return node;
}

template<class T>
RBTreeNode<T> *  RBSearchTree<T>::TreePredecessor(RBTreeNode<T> *node)
{
    if(node->left !=NILNode)
    {
        RBTreeNode<T> * temp = MaximumInner(node->left);
        return temp;
    }
    RBTreeNode<T> * temp = node->p;
    while( temp!=NILNode && node == temp->left)
    {
        node = temp;
        temp = temp->p;
    }
    if (temp == NILNode)
        temp = new RBTreeNode<T>(new Interval<T>(-1,-1)); //表示没有前驱
    return temp;
}

template<class T>
RBTreeNode<T> *  RBSearchTree<T>::TreeSuccessor(RBTreeNode<T> *node)
{
    if(node->right !=NILNode)
    {
        RBTreeNode<T> * temp = MinimumInner(node->right);
        return temp;
    }
    RBTreeNode<T> * temp = node->p;
    while( temp!=NILNode && node == temp->right)
    {
        node = temp;
        temp = temp->p;
    }
    if (temp == NILNode)
        temp = new RBTreeNode<T>(new Interval<T>(-1,-1)); //表示没有后继
    return temp;
}

template<class T>
string RBSearchTree<T>::Delete(Interval<T> *i)
{
    RBTreeNode<T> *node = Search(i);//找到要删除的节点
    RBTreeNode<T> *backupsNode; //备份指针，用于保存节点长度发生变化的节点（发生继承关系的节点）
    RBTreeNode<T> *successorNode = NILNode; //用于保存后继节点的父节点，计算max用
    NodeColor originColor = node->color;//记录原始颜色（如果删除的是黑色是会影响黑高的，红色则不会）
    if(node->left==NILNode) //单左节点
    {
        backupsNode = node->right;
        RBTransplant(node,node->right);
    }
    else if(node->right==NILNode)//单右节点
    {
        backupsNode = node->left;
        RBTransplant(node,node->left);
    }
    else
    {
    	//找到后继节点
        RBTreeNode<T> *temp = MinimumInner(node->right);
        originColor = temp->color;
        if (temp->p == node)
            backupsNode->p = temp;
        else //if (temp->p != node)
        {
            RBTransplant(temp,temp->right);
            temp->right = node->right;
            temp->right->p = temp;
        }
        RBTransplant(node,temp);
        temp->left = node->left;
        temp->left->p = temp;
        temp->color = node->color;
    }
    //如果删除的是在末节点，影响的还是只有他到root最简单路径上的点
    //但是当删除的点不是末端节点的时候，影响的就是后继节点到root最简单路径上的点
    if (successorNode==NILNode)
        CalMaxToRoot(node);
    else
        CalMaxToRoot(successorNode);
    if (originColor == NodeColor(BLACK))
        RBTreeDeleteFix(backupsNode);
    return strTrue;
}

template<class T>
RBSearchTree<T>::RBTreeDeleteFix(RBTreeNode<T> *node)
{
    while (node != root && node->color == NodeColor(BLACK))
    {
        if (node == node->p->left)
        {
            RBTreeNode<T> *broNode = node->p->right;
            if (broNode->color == NodeColor(RED))
            {
                broNode->color = NodeColor(BLACK);
                node->p->color = NodeColor(RED);
                LeftRotate(node->p);
                broNode = node->p->right;
            }
            if (broNode->left->color == NodeColor(BLACK) &&broNode->right->color == NodeColor(BLACK))
            {
                node = node->p;
                broNode->color = NodeColor(RED);
            }
            else if (broNode->left->color == NodeColor(RED))
            {
                broNode->left->color = NodeColor(BLACK);
                broNode->color = NodeColor(RED);
                RightRotate(broNode);
                broNode = node->p->right;
            }
            else
            {
                broNode->right->color == NodeColor(BLACK);
                broNode->color = broNode->p->color;
                broNode->p->color = NodeColor(BLACK);
                LeftRotate(node->p);
                node = root;//用于终止循环
            }
        }
        else
        {
            RBTreeNode<T> *broNode = node->p->left;
            if (broNode->color == NodeColor(RED))
            {
                broNode->color = NodeColor(BLACK);
                node->p->color = NodeColor(RED);
                RightRotate(node->p);
                broNode = node->p->left;
            }
            if (broNode->left->color == NodeColor(BLACK) &&broNode->right->color == NodeColor(BLACK))
            {
                node = node->p;
                broNode->color = NodeColor(RED);
            }
            else if (broNode->right->color == NodeColor(RED))
            {
                broNode->right->color = NodeColor(BLACK);
                broNode->color = NodeColor(RED);
                RightRotate(broNode);
                broNode = node->p->left;
            }
            else
            {
                broNode->left->color == NodeColor(BLACK);
                broNode->color = broNode->p->color;
                broNode->p->color = NodeColor(BLACK);
                LeftRotate(node->p);
                node = root;//用于终止循环
            }
        }
    }
    node->color = NodeColor(BLACK);
}

template<class T>
RBSearchTree<T>::LeftRotate(RBTreeNode<T> *node)
{
    RBTreeNode<T> *y = node->right;
    node->right = y->left;
    if (y->left !=NILNode)
        y->left->p = node;
    y->p = node->p;
    if (node->p == NILNode)
        root = y;
    else if (node->p->left ==  node)
        node->p->left = y;
    else
        node->p->right = y;
    y->left = node;
    node->p = y;

    CalMax(node);
    CalMax(y);
}

template<class T>
RBSearchTree<T>::RightRotate(RBTreeNode<T> *node)
{
    RBTreeNode<T> *y = node->left;
    node->left = y->right;
    if (y->right !=NILNode)
        y->right->p = node;
    y->p = node->p;
    if (node->p == NILNode)
        root = y;
    else if (node->p->left == node)
        node->p->left = y;
    else
        node->p->right = y;
    y->right = node;
    node->p = y;

    CalMax(node);
    CalMax(y);
}

template<class T>
RBSearchTree<T>::CalMaxToRoot(RBTreeNode<T> *node)
{
    //这里可以做一个小优化，当删除的节点是root或者 node->i->high < node->p->max的时候，可以直接return
    while(node->p !=NILNode)
    {
        CalMax(node);
        node = node->p;
    }
}

template<class T>
T FindMax(T x,T y)
{
    if (x>y)
        return x;
    else
        return y;
}

template<class T>
RBSearchTree<T>::CalMax(RBTreeNode<T> *node)
{
    T num1 = node->i->high;
    T num2 = node->left->max;
    T num3 = node->right->max;
    if (node->left == NILNode)
        num2 = num1-1;
    if (node->right == NILNode)
        num3 = num1-1;
    node->max = FindMax(FindMax(num1,num2),num3);
}

int main()
{
    Interval<int> *a[10] = {
        new Interval<int>(16,21),
        new Interval<int>(8,9),
        new Interval<int>(5,8),
        new Interval<int>(15,23),
        new Interval<int>(0,3),
        new Interval<int>(6,10),
        new Interval<int>(26,26),
        new Interval<int>(25,30),
        new Interval<int>(17,19),
        new Interval<int>(19,20),
    };
    RBSearchTree<int> *tr = new RBSearchTree<int>(a,10);
    tr->MidWalk();
    RBTreeNode<int> *node = tr->Search(new Interval<int>(22,25));
    cout<<"["<<node->i->low<<","<<node->i->high<<"]"<<endl;
    node = tr->Search(new Interval<int>(11,14));
    cout<<"["<<node->i->low<<","<<node->i->high<<"]"<<endl;
    tr->Delete(new Interval<int>(6,10));
    tr->MidWalk();
}

运行结果如下
在这里插入图片描述
我在不同的电脑上运行，有时候会得到下面的结果
在这里插入图片描述
上述结果是一样的，不过下面的图是用16进制表达的（不信你可以自己算算看，14是16+4=20），出现上述两种结果的原因不详，运行环境实在CodeBlock

补充：
1、红黑树的创建规则改变为， i.low小的放在left，i.low大的放在右节点
2、封装了一个计算max的方法CalMax(RBTreeNode *node)
3、对原有的Search方法进行更改，规则改为：如果i.low≤i’.high且i.high≥i’.high，则i和i’重叠，返回i’。i为搜索的区间，i’为搜索树中节点的区间。

1、2两点比较好理解，就不进行说明了，这里主要说一下第3点。
①while(node !=NILNode && (i->low > node->i->high || i->high < node->i->low))，这个循环条件很清晰，就是说明了两件事：从根节点找到叶节点（NILNode）；整个过程中都没有重叠节点
②if (node->left != NILNode && node->left->max >= i->low)，这个条件判断的是当左节点存在，并且left.max≥i.low的时候，从左子树中搜索重合点，否则从右节点搜索。
(1)我们首先判断 右节点的条件，也就是 node = node->right 的情况：
无论左节点是否为NILNode节点，当node->left->max >= i->low 不满足的时候，即node->left->max < i->low，此时已经违背了重叠的原则 “i.low≤i’.high且i.high≥i’.high”，所以如果存在重叠节点，只能在右节点中，如下图(a)。
(2)接着我们来判断左节点的条件，也就是 node = node->left 的情况：
因为 node->left->max >= i->low ，所以左子树中一定存在区间i’满足
i->low ≤ node->left.max = i’->high 如下图(b)所示。此时如果左子树中找不到重叠区间，右子树中一定不存在重叠节点，因为右节点的 i’->low一定大于i.high在这里插入图片描述
区间树在DDM区域匹配中的应用

在逆境中蜕变
关注
专栏目录
在红黑树的基础上实现区间树的创建，左旋，右旋，插入和查找
浮生如梦
04-23 1382
题目：在红黑树的基础上实现区间树的创建，左旋，右旋，插入和查找 算法思想： 区间树介绍：       区间树是在红黑树基础上进行扩展得到的支持以区间为元素的动态集合的操作，其中每个节点的关键值是区间的左端点。区间[low,high]表示成一个对象i,low表示区间的低点，high表示区间的高点。通过建立这种特定的结构，可使区间的元素的查找和插入都可以在O(lgn)的时间内完成。 相比于红
bom树形结构 表设计_BOM模块常用表结构
weixin_33618737的博客
02-23 3237
表名: bom.bom_bill_of_materials说明: BOM清单父项目BILL_SEQUENCE_ID NUMBER 清单序号(关键字)ASSEMBLY_ITEM_ID NUMBER 装配件内码ORGANIZATION_ID NUMBER 组织代码ASSEMBLY_TYPE NUMBER 装配类别SPECFIIC_ASSEMBLY_COMMENT VARCHAR2(240) 注释(装配...
数据结构-红黑树扩张-区间树
mark's technic world
03-20 1001
package com.data.struct; public class IntervalTree { private Node root; //private Node nil; public IntervalTree(int [][]data){ for(int i=0;i<data.length;i++){ Node node=new Node(); node
【算法导论随笔】第三部分2 二叉搜索树与红黑树与区间树
carvingfate的博客
09-07 330
BST(排序二叉树/搜索树) 排序：中序遍历 同快排一样，有序时挨个插入元素O（n^2），所以先对数组随机化 后继和前驱 https://blog.csdn.net/qq_42403295/article/details/88758816 证明BST高度期望值是logn Cormen课上用到的思路：令y=2^x,然后证明y 因为比如 max(a,b)<=a+b max(2的a次方与2的b次方)<=2的a次方+2的b次方 当|a-b|逐渐增大时，后者收敛速度比前者快 ...
红黑树、区间树
11-15
红黑树继承二叉查找树，区间树继承红黑树，main函数中写的是区间树的测试程序
算法导论习题—二叉搜索树、红黑树、区间树
最新发布
我们都是被分成两半的人，一边热爱生活，一边憎恨生活。面对生活，我们总是在矛盾的两端摇摆，在反复的矛盾和犹豫中，一边踉跄前行，一边重振旗鼓。我渴望改变，渴望变得更好，渴望找到出口……就像一个溺水人的挣扎，就像一个救生圈。我是一个矛盾集合体，想要变得快乐，但是
10-20 620
假设取得一个不在区间端点上的最大重叠点，对于这个点，其所在的区间的左端点或右端点中，必定存在一个端点与这个最大重叠点有着相同的区间数，所以，在最大重叠点中，一定存在一个点是其中一个区间的端点。之前出现的区间，只出现了左端点，还没有出现右端点，那么说明该区间与。使用红黑树存储各个区间的端点值，对于每个结点。值，其余操作与红黑树的插入操作相同。值，其余操作与红黑树的删除操作相同。为根节点的树中最大重叠点的重叠数。为根结点的子树中的最小端点值为。的右孩子结点，则此时结点。，若结点为一个左端点，则。
大数据学习之旅-02-红黑树源码
01-10
本主题将聚焦于红黑树的源码解析，以Zookeeper 3.4.7版本为例，深入理解其在实际应用中的实现细节。 Zookeeper是Apache的一个开源项目，主要用于分布式协调服务，它依赖于高效的数据结构来保证服务的稳定性和性能。...
数据结构学习——哈夫曼树
YiHeboy的博客
07-13 2950
哈夫曼树的构建以及哈夫曼编码的生成
分治技巧在高级数据结构中的应用——线段树分治（二）&&bzoj4137火星商店问题详解
maxtir的博客
12-01 2708
分治技巧在高级数据结构中的应用——线段树分治（二） 从一道神题说起 4137: [FJOI2015]火星商店问题 Time Limit: 20 Sec  Memory Limit: 256 MB Submit: 210  Solved: 98 [Submit][Status][Discuss] Description 火星上的一条商业街里按照商店的编号1，2 ，…，n ，
Java中Calendar对于日期的控制详解--DAY_OF_MONTH, DAY_OF_YEAR, DATE 的区别
热门推荐
jerrygaoling的博客
11-27 2万+
文章目录前言创建测试代码执行结果结果分析 前言 开发过程中经常遇到对时间的操作，通过具体的实验完成对时间类Calendar的基本使用方法。 创建测试代码 package action; import java.text.SimpleDateFormat; import java.util.Calendar; public class TestCalendar { public static void getCaltime() { SimpleDateFormat sdf = new Simpl
Linux内核中使用红黑树的扩展特性实现区间树（Interval tree）
雜貨鋪
02-03 2021
原文地址：http://galex.cn/linux%E5%86%85%E6%A0%B8%E4%B8%AD%E4%BD%BF%E7%94%A8%E7%BA%A2%E9%BB%91%E6%A0%91%E7%9A%84%E6%89%A9%E5%B1%95%E7%89%B9%E6%80%A7%E5%AE%9E%E7%8E%B0%E5%8C%BA%E9%97%B4%E6%A0%91%EF%BC%88int
Day_24，数据结构扩张以红黑树为基础（简单扩充卫星数据）
weixin_40301728的博客
07-07 224
书写思路： 1、动态顺序统计引入扩张红黑树的实现 2、总结方法 3、红黑树扩张为区间树
算法导论 红黑树的扩张 动态顺序统计
苦海无涯闯进来
05-16 437
1
利用红黑树实现的线段/区间有序集合
qq_41323538的博客
01-29 280
最近公司有这样一个需求: 放置一系列区间(可能有交集,也可能很稀疏),然后判断给定点是否命中某些区间. 举个例子, 设有区间 A[10,100), B[30,80), C[1000,2000),给定点 P=60,判断命中哪些区间? 答案:A区间, B区间. 实际业务中还需要存储一些值,所以需要构造一个有序集合TreeMap,且将重叠的区间拆分开存储. 在此集合中存储形式如下: A1[10,30), A2B[30,80), A3[80,100), C[1000,2000) 刚开始我直接使用ja
使用红黑树扩展数据结构，求区间最大重叠点
qq_42890800的博客
10-30 673
目录问题描述求解过程a.证明b.设计数据结构扩增INTERVAL-INSERT操作：INTERVAL-DELETE操作：\left \{ l(x),...,r(x)\}FIND-POM算法： 在网上找了一些资料，发现讲述得都不大清晰，所以在这里总结一下。 问题描述 假设我们希望记录一个区间集合的最大重叠点，即被最多数目区间所覆盖的那个点。 a. 证明：最大重叠点一定是其中一个区间的端点 b. 设计...
算法导论 第十四章：区间树
dllTimes
07-16 1万+
区间树是一种对动态集合进行维护的红黑树，具体设计如下： step1:基础数据结构    我们选择的基础数据结构式红黑树，其中每个节点增加
算法导论 14章 数据结构的扩张(二) 区间树
V然成风
02-05 1032
区间树——红黑树的扩张           将红黑树进行扩张以支持由区间构成的动态集合，其节点主要除红黑树节点常规信息之外，还有一个区间信息，这样的一颗树称之为区间树。我们将利用14.2节总结的红黑树扩张的四个步骤来讨论如何进行扩充以得到区间树。 步骤1：基础数据结构         毫无疑问，我们将选择红黑树。该区间树的每个节点有一个区间信息，对于节点x，即为int[x]，用low表示in
查找算法——红黑树
weixin_33786077的博客
10-31 642
引言：红黑树的出现与定义 1. BST(二叉查找树)存在的问题 　　BST存在的主要问题是，数在插入的时候会导致树倾斜，不同的插入顺序会导致树的高度不一样，而树的高度直接的影响了树的查找效率。理想的高度是logN，最坏的情况是所有的节点都在一条斜线上，这样的树的高度为N。 2. 红黑二叉树的定义与应用 　　基于BST存在的问题，一种新的树...
算法导论34--区间树（Python）
勇气与行动
05-29 1631
区间树： 闭区间是一个实数的有序对[t1, t2]，其中t1 我们可以把一个区间[t1, t2]表示成一个对象i。其中属性i.low=t1为低端点，属性i.high=t2为高端点。 区间i和i'重叠：i.low 区间树是一种动态集合进行维护的红黑树，其中每个元素x都包含一个区间x.int。 每个结点x:包含一个区间属性x.int。且x的关键字为区间的低端点
数据结构提炼压缩：树形结构的高效处理
"树形结构的化简-数据结构的提炼与压缩" 在计算机科学中，数据结构的化简和压缩是一种优化技术，旨在减少存储需求、简化存储结构以及提高算法的时空效率。这一过程通常涉及三个主要手段：提炼、压缩和合并。 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值