算法导论 区间树

最新推荐文章于 2022-09-14 21:56:24 发布
最新推荐文章于 2022-09-14 21:56:24 发布
阅读量448 收藏 1
点赞数
分类专栏： 算法导论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/niewei1986/article/details/72470058
版权 
#include <stdio.h>      
#include <stdlib.h>      
#define RED 1      
#define BLACK 0      
      
typedef struct  
{  
    int low;  
    int high;  
}KeyType,*KT;  
  
typedef struct RBTreeNode      
{      
    KT key;      
    int color;  
    int max;  
    RBTreeNode *p;      
    RBTreeNode *left;      
    RBTreeNode *right;      
}RBT,*pRBT;      
      
pRBT nil=(pRBT)malloc(sizeof(RBT));      
int bh=0;    
    
void initNil()      
{      
    nil->key=(KT)malloc(sizeof(KeyType));  
    nil->key->low=-1;  
    nil->key->high=-1;  
    nil->color=BLACK;      
    nil->p=NULL;      
    nil->left=NULL;      
    nil->right=NULL;   
    nil->max=-1;  
}      
  
int max(int a,int b,int c)  
{  
    if(a>=b && a>=c)  
        return a;  
    else if(b>=c)  
        return b;  
    else  
        return c;  
}  
      
void leftRotate(pRBT *root,pRBT x)      
{      
    //左旋要有右子树      
    if(x->right==nil)      
        return;      
    pRBT y=x->right;      
    x->right=y->left;      
    if(y->left != nil)      
        y->left->p=x;      
    y->p=x->p;      
    if(x->p==nil)      
    {      
        (*root)=y;      
    }      
    else if(x == x->p->left)      
    {      
        x->p->left=y;      
    }      
    else      
    {      
        x->p->right=y;      
    }      
    y->left=x;      
    x->p=y;   
    x->max=max(x->key->high,x->left->max,x->right->max);  
    y->max=max(y->key->high,y->left->max,y->right->max);  
}      
      
void rightRotate(pRBT *root,pRBT y)      
{      
    //右旋要有左子树      
    if(y->left==nil)      
        return;      
    pRBT x=y->left;      
    y->left=x->right;      
    x->p=y->p;      
    if(x->right != nil)    
        x->right->p=y;    
    if(y->p==nil)      
    {      
        (*root)=x;      
    }      
    else if(y==y->p->left)      
    {      
        y->p->left=x;      
    }      
    else      
    {      
        y->p->right=x;      
    }      
    x->right=y;      
    y->p=x;     
    y->max=max(y->key->high,y->left->max,y->right->max);  
    x->max=max(x->key->high,x->left->max,x->right->max);  
}      
      
void rbInsertFixup(pRBT *root,pRBT z)      
{      
    while(z->p->color==RED)      
    {      
        if(z->p==z->p->p->left)      
        {      
            pRBT y=z->p->p->right;      
            if(y->color==RED)      
            {      
                z->p->color=BLACK;      
                y->color=BLACK;      
                z->p->p->color=RED;      
                z=z->p->p;      
            }      
            else       
            {      
                if(z==z->p->right)      
                {      
                    z=z->p;      
                    leftRotate(root,z);      
                }      
                z->p->color=BLACK;      
                z->p->p->color=RED;      
                rightRotate(root,z->p->p);      
            }      
        }      
        else      
        {      
            pRBT y=z->p->p->left;      
            if(y->color==RED)      
            {      
                z->p->color=BLACK;      
                y->color=BLACK;      
                z->p->p->color=RED;      
                z=z->p->p;      
            }      
            else       
            {      
                if(z==z->p->left)      
                {      
                    z=z->p;      
                    rightRotate(root,z);      
                }      
                z->p->color=BLACK;      
                z->p->p->color=RED;      
                leftRotate(root,z->p->p);      
            }      
        }      
    }      
    if((*root)==nil || (*root)->color==RED)    
        bh++;    
    (*root)->color=BLACK;    
        
}      
      
void rbInsert(pRBT *root,KT key)      
{      
    pRBT z=(pRBT)malloc(sizeof(RBT));      
    z->key=key;      
    pRBT x=(*root);      
    pRBT y=nil;      
    while(x != nil)      
    {      
        y=x;      
        if(z->key->low<x->key->low)      
        {      
            x=x->left;      
        }      
        else      
        {      
            x=x->right;      
        }      
    }      
    z->p=y;      
    if(y==nil)      
    {      
        (*root)=z;      
    }      
    else if(z->key->low<y->key->low)      
    {      
        y->left=z;      
    }      
    else      
    {      
        y->right=z;      
    }      
    z->left=nil;      
    z->right=nil;      
    z->color=RED;
	pRBT u=z;
	while(u!=nil)
	{
		u->max=max(u->key->high,u->left->max,u->right->max); 
		u=u->p;
	}
    rbInsertFixup(root,z);      
}    
    
void rbTransplant(pRBT *root,pRBT u,pRBT v)    
{    
    if(u->p==nil)    
        (*root)=v;    
    else if(u==u->p->left)    
        u->p->left=v;    
    else    
        u->p->right=v;    
    v->p=u->p;    
}    
    
pRBT treeMinimum(pRBT root)    
{    
    if(root==nil)    
        return root;    
    pRBT x=root;    
    while(x->left!=nil)    
    {    
        x=x->left;    
    }    
    return x;    
}    
    
void rbDeleteFixup(pRBT *root,pRBT x)    
{    
    while(x != *root && x->color==BLACK)    
    {    
        if(x==x->p->left)    
        {    
            pRBT w=x->p->right;    
            if(w->color==RED)    
            {    
                w->color=BLACK;    
                x->p->color=RED;    
                leftRotate(root,x->p);    
                w=x->p->right;    
            }    
            if(w->left->color==BLACK && w->right->color==BLACK)    
            {    
                w->color=RED;    
                x=x->p;    
                if(x==*root)    
                    bh--;    
            }    
            else    
            {    
                if(w->right->color == BLACK)    
                {    
                    w->left->color=BLACK;    
                    w->color=RED;    
                    rightRotate(root,w);    
                    w=x->p->right;    
                }    
                w->color=x->p->color;    
                x->p->color=BLACK;    
                w->right->color=BLACK;    
                leftRotate(root,x->p);    
                x=(*root);    
            }    
        }    
        else    
        {    
            pRBT w=x->p->left;    
            if(w->color==RED)    
            {    
                w->color=BLACK;    
                x->p->color=RED;    
                rightRotate(root,x->p);    
                w=x->p->left;    
            }    
            if(w->left->color==BLACK && w->right->color==BLACK)    
            {    
                w->color=RED;    
                x=x->p;    
            }    
            else    
            {    
                if(w->left->color == BLACK)    
                {    
                    w->right->color=BLACK;    
                    w->color=RED;    
                    leftRotate(root,w);    
                    w=x->p->left;    
                }    
                w->color=x->p->color;    
                x->p->color=BLACK;    
                w->left->color=BLACK;    
                rightRotate(root,x->p);    
                x=(*root);    
            }    
        }    
    }    
        
    x->color=BLACK;    
}    
    
void rbDelete(pRBT *root,pRBT z)    
{    
    pRBT y=z,x;    
    int yOrigColor=y->color;    
    if(z->left==nil)    
    {    
        x=z->right;    
        rbTransplant(root,z,x);    
    }    
    else if(z->right==nil)    
    {    
        x=z->left;    
        rbTransplant(root,z,x);    
    }    
    else    
    {    
        y=treeMinimum(z->right);    
        yOrigColor=y->color;    
        x=y->right;    
        if(y->p==z)    
        {    
            x->p=y;    
        }    
        else    
        {    
            rbTransplant(root,y,x);    
            y->right=z->right;    
            y->right->p=y;    
        }    
        rbTransplant(root,z,y);    
        y->left=z->left;    
        y->left->p=y;    
        y->color=z->color;  
        free(z->key);  
        free(z);
		pRBT u=x;
		while(u!=nil)
		{
			u->max=max(u->key->high,u->left->max,u->right->max); 
			u=u->p;
		}
        if(yOrigColor==BLACK)    
            rbDeleteFixup(root,x);    
    }    
}    
    
void preTrav(pRBT root,char c)    
{    
    if(root==nil)    
        return;    
    else    
    {    
        printf("(%d,%d) ",root->key->low,root->key->high);  
        printf("%d ",root->max);  
        if(root->color==BLACK)    
            printf("%s ","黑");    
        else    
            printf("%s ","红");    
        printf("%c ",c);   
        printf("\n");  
        preTrav(root->left,'L');    
        preTrav(root->right,'R');    
    }    
}    
    
bool isOverlap(KT x,KT y)  
{  
    return x->low<=y->high && y->low<=x->high;  
}  
  
pRBT intervalSearch(pRBT root,KT i)  
{  
    pRBT x=root;  
    while(x!=nil && !isOverlap(i,x->key))  
    {  
        if(x->left && x->left->max>=i->low)  
            x=x->left;  
        else  
            x=x->right;  
    }  
    return x;  
}  
KT newKT(int low,int high)  
{  
    KT x=(KT)malloc(sizeof(KeyType));  
    x->low=low;  
    x->high=high;  
    return x;  
}  
void main()    
{    
    initNil();    
    pRBT root=nil;    
    rbInsert(&root,newKT(0,3));   
    rbInsert(&root,newKT(5,8));  
    rbInsert(&root,newKT(6,10));  
    rbInsert(&root,newKT(8,9));  
    rbInsert(&root,newKT(15,23));  
    rbInsert(&root,newKT(16,21));  
    rbInsert(&root,newKT(25,30));  
    rbInsert(&root,newKT(17,19));  
    rbInsert(&root,newKT(26,26));  
    rbInsert(&root,newKT(19,20));  
  
    preTrav(root,'M');    
    printf("\n");     
    KT y=newKT(22,25);  
    pRBT z=intervalSearch(root,y);  
    printf("%d,%d",z->key->low,z->key->high);   
    getchar();    
}

niewei1986
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
区间树查找区间算法的实现
04-17
区间树查找区间算法的实现，VC++实现，自动随机生成区间，查找最小区间和调度区间
线段树（区间树）-查询和更新
swadian2008的博客
04-29 2054
一、为什么需要使用线段树 在一个区间内，需要同时实现两个操作：更新+查询，如果我们仅仅使用数组来实现，它的时间复杂度时O(n)级别的，相对来说，如果我们使用线段树，便可以获得更好的时间复杂度和更高的执行效率。 例如，我们需要在一个数组中，求一个区间内的元素的和，如果我们使用数组来进行实现，需要找到数组中所有的这些元素，然后进行一个一个的遍历求和操作，如果数据量很大的化，这种操作时比较低效的...
线段树（区间树）
weixin_30877227的博客
10-18 209
线段树(Interval Tree)，也叫区间树。它在各个节点保存一个区间（即“子数组”），适用于和区间统计有关的问题。比如某些数据可以按区间进行划分，按区间动态进行修改，而且还需要按区间多次进行查询，那么使用线段树可以达到较快查询速度。实际可应用于例如RMQ，线段求长，矩形交，矩形并等，它基本能保证每个操作的复杂度为O(log n)。 一、基本结构 对于一个[0 , N-1]的序列，它...
数据结构——线段树(区间树)
zp的博客
10-27 9022
一、为什么要使用线段树？ 线段树又称为区间树，Segment Tree，对于有一类的问题，我们关心的是线段(或者区间)，有一个非常经典的例子：区间染色 问题1：有一面墙，长度为n，每次选择一段墙进行染色，n次操作后，我们可以在[i,j]区间内看见多少种颜色？ 实际上这道题可以拆分为两个步骤： ①染色操作(更新区间) ②查询操作(查询区间) 如果都使用数组实现的话，染色和查询操作时间复杂...
区间树上的重叠区间查找算法
Icyfire Talks
01-27 7180
 实验目的：         熟悉并实现区间树上的重叠区间查找算法，分析该算法的性能。问题定义         尝试构造一个区间树。         可依次插入下列数组中的元素：[8,9] [ 5,8] [15,23] [0,3] [6,10] [25,30] [17,19] [26,26] [19,20]查找重叠区间：“find [22,25]”或“find [11,14
红黑树与区间树算法实现
04-08
红黑树和区间树是两种在计算机科学中广泛使用的数据结构，主要应用于高效的数据管理和查询。在本实验中，我们探讨了如何用C++来实现这两种数据结构，并提供了相关的可视化功能。 红黑树是一种自平衡二叉查找树，由...
MIT算法导论公开课之课程笔记 11.扩充的数据结构、动态有序统计和区间树.rar
07-06
总之，《MIT算法导论公开课》中的这部分内容深入介绍了如何通过扩展基本数据结构来解决更复杂的问题，以及如何利用动态有序统计和区间树来高效地处理区间查询和更新。这些知识对于提升算法设计能力和解决实际问题...
算法导论中文版
10-26
　14.3　区间树 　思考题 　本章注记 第四部分　高级设计和分析技术 第15章　动态规划 　15.1　钢条切割 　15.2　矩阵链乘法 　15.3　动态规划原理 　15.4　最长公共子序列 　15.5　最优二叉搜索树 　思考题 　本章...
区间树的查询操作c++
12-03
实验进行的是区间树的查询操作，参照的是《算法导论》中关于区间树的描述，在红黑树的基础上加以改造实现，采用的是c++。代码已经过测试可用
区间树的重叠区间查找算法
12-17
算法导论，在红黑树的基础上扩张出区间树的数据结构，并且构造区间树的重叠区间查找算法。
Leetcode 每日一题——57. 插入区间
qq_41978896的博客
11-04 222
57. 插入区间 给出一个无重叠的 ，按照区间起始端点排序的区间列表。 在列表中插入一个新的区间，你需要确保列表中的区间仍然有序且不重叠（如果有必要的话，可以合并区间）。 该题目是一个升级版的区间合并问题，具体代码如下（Python版）： class Solution: def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]: result=list()
数据结构之区间树
有梦想的小新人的博客
09-07 1265
区间树 (Interval tree), 是一种二叉搜索树。它将一个区间划分成一些单元区间(即单个数据)，每个单元区间对应一个叶节点，非叶节点表示其所代表的子树对应的子区间。区间树中，每个节点的子节点分别表示它的左右半区间。对于每一个非叶节点 ，设其对应区间为[a, b]，它的左子树表示的区间为[a, (a+b)/2], 右子树表示的区间为[(a+b)/2+1, b] (1)区间树的建立核心代码： //包括begin，不包括end void build(int node,int begin,int end)
【数据结构】线段树（区间树）
明月沉江春雾晓
07-24 2176
文章目录概述实现 概述 线段树也称为“区间树”，它的适用场景也是很普遍的，关注的重点是“线段”，或者说是区间。非常经典的线段树题目是“区间染色”，搜搜看呗！ 有的时候我们处理的数据的时候也需要进行区间的查询，比如说查询一个区间[i，j]的最大值，最小值，或者区间数字和。换成生活中的场景就是在2019年一年中，你的博客在什么时间段关注你的人增长最快啊，一天中自己的博文阅读量最高的时间段啊，某个星系中...
《算法导论》14.3 区间树
最新发布
Toby的博客
09-14 594
本文为《算法导论》14.3 区间树的笔记，欢迎参考！
区间树
sonemeen22的博客
03-15 408
区间树，以区间的低端点作为key区分，将区间集合的各个元素，即区间，存储到红黑树的节点中，并且存储上这个节点的子树的最大高端值。 所有的基本操作是： Interval_insert(T, x); 将区间x插入到区间树T中。 Interval_delete(T, x); 将区间x从区间树T中删除。 Interval_search(T, x); 返回一个和x的区间重叠的节点。
二维线段树——区间最值系列
mumei的博客
01-27 2235
最近这几天学习了一下二维线段树，二维线段树主要有两种写法，四分树和树套树，暂时还没写过四分树，因为这个东西确实不常用，而且不好写也不好调。 树套树的写法思路其实不难，首先我们知道，我们通常的线段树的操作都是在线段上进行的，即一维的，当推广到二维上，即矩阵时，我们就把它叫做二维线段树。 二维线段树其实就是我们再操作时先找到对应x轴的区间（即第一维），之后再找到对应y轴的区间（即第二维），进行相...
线段树(区间树) SegmentTree
Sumuxi9797926的博客
07-22 165
线段树可以用数组的形式构建，也可以用链表的方式构建，本文使用数组的方式构建。
算法导论 第十四章：区间树
热门推荐
dllTimes
07-16 1万+
区间树是一种对动态集合进行维护的红黑树，具体设计如下： step1:基础数据结构    我们选择的基础数据结构式红黑树，其中每个节点增加
Centered Interval tree 介绍（中心区间树）
乔的博客
10-12 2055
参考：https://en.wikipedia.org/wiki/Interval_tree 百度很多关于interval tree和segment tree的感觉都有问题，于是去Wikipedia查了一下interval tree，在这里总结一下。 线段树用来索引线段，比如时间段[1,10], [3,7], [20,30]，主要支持点查询，比如查找时间点4，会查出[1,10]和[3,7]，范...
麻省理工学院算法导论
03-23
《麻省理工学院算法导论》是一本非常牛B的算法教材，由Thomas H. Cormen、Charles E. Leiserson、Ronald L. Rivest和Clifford Stein共同编写。该书由麻省理工学院电气工程与计算机科学系的教授所编写，由The MIT出版...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值