算法导论——区间树上的重叠区间查找算法

最新推荐文章于 2024-03-11 22:00:15 发布
最新推荐文章于 2024-03-11 22:00:15 发布
阅读量2.1k 收藏 10
点赞数 1
分类专栏： 数据结构 文章标签： 算法导论 算法 区间树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaowang627/article/details/55549407
版权

一、   算法设计与分析：

（1）   数据结构设计：

//区间
struct Interval{
  int low;
  int high;
};

//节点
struct Node{
  Node(int low,int high){
         this->key=low;
         this->Int.low=low;
         this->Int.high=high;
         this->max=high;
  }
  int key;
  int color;
  int max;
  Interval Int;
  Node* parent;
  Node* left;
  Node* right;
};

//树
struct Tree{
  Tree(){
  }
  Node* root;
  Node* nil;
};

（2）区间树上的重叠区间查找算法设计如下：

OS_SELECT(x,i)

  r=x.left.size+1;

  if i==r

return x;

else if i<r

 return OS_SELECT(x.left,i)

else

 return OS_SELECT(x.right,i-r)

二、算法实现

#pragma once
#define RED 0
#define BLACK 1

//区间
struct Interval{
	int low;
	int high;
};

//节点
struct Node{
	Node(int low, int high){
		this->key=low;
		this->Int.low=low;
		this->Int.high=high;
		this->max=high;
	}
	int key;
	int color;
	int max;
	Interval Int;
	Node* parent;
	Node* left;
	Node* right;
};

//树
struct Tree{
	Tree(){
	}
	Node* root;
	Node* nil;
};

#define MAXSIZE 10
#include "Tree.h"
#include <iostream>
#include <climits>
#include <string>
#include <map>
using namespace std;
void RB_INSERT(Tree* &T,Node* z);
void RB_INSERT_FIXUP(Tree* &T, Node* z);
void LEFT_ROTATE(Tree* &T, Node* x);
void RIGHT_ROTATE(Tree* &T, Node* y);
void InOrder(Node* tree,Tree* T);
void PreOrder(Node* tree,Tree* T);
//为区间树添加的方法
void FixMax(Node* node, Tree* T);
int Max(int a, int b, int c);
Node* INTERVAL_SEARCH(Tree* T, Interval i);
bool Overlap(Interval a, Interval b);
Node* INTERVAL_SEARCH(Tree* T, Interval i);

int main(){
	Tree* T;
	Node* z[MAXSIZE];

	T=new Tree();
	T->nil=new Node(0,0);
	T->nil->color=BLACK;
	T->nil->max=INT_MIN;
	T->root=T->nil;

	int i=0;
		z[i]=new Node(16,21);
		RB_INSERT(T,z[i]);
		i++;

		z[i]=new Node(8,9);
		RB_INSERT(T,z[i]);
		i++;

		z[i]=new Node(25,30);
		RB_INSERT(T,z[i]);
		i++;

		z[i]=new Node(5,8);
		RB_INSERT(T,z[i]);
		i++;

		z[i]=new Node(15,23);
		RB_INSERT(T,z[i]);
		i++;

		z[i]=new Node(17,19);
		RB_INSERT(T,z[i]);
		i++;
		z[i]=new Node(26,26);
		RB_INSERT(T,z[i]);
		i++;
		z[i]=new Node(0,3);
		RB_INSERT(T,z[i]);
		i++;
		z[i]=new Node(6,10);
		RB_INSERT(T,z[i]);
		i++;
		z[i]=new Node(19,20);
		RB_INSERT(T,z[i]);
	
	PreOrder(T->root,T);
	cout << endl;
	InOrder(T->root,T);
	
	cout << endl;
	Node* node;
	Interval Int;
	Int.low=11;
	Int.high=14;
	node=INTERVAL_SEARCH(T,Int);
	if(node!=T->nil)
		cout << node->Int.low << "," << node->Int.high << endl;
	else
		cout << "未找到与该区间重叠的区间" << endl;
	
	return 0;
}

//插入节点
void RB_INSERT(Tree* &T,Node* z){
	Node* y=T->nil;
	Node* x=T->root;
	while(x!=T->nil){
		y=x;
		if(z->key < x->key)
			x=x->left;
		else
			x=x->right;
	}
	z->parent=y;
	if(y==T->nil)//插入第一个元素
		T->root=z;
	else if(z->key < y->key)
		y->left=z;
	else
		y->right=z;
	z->left=T->nil;
	z->right=T->nil;
	z->color=RED;
	FixMax(z,T);//插入完成自底向上调整max
	RB_INSERT_FIXUP(T,z);//调整颜色过程只有旋转需要改变max值，所以该算法不用改变
}

//红黑树调整
void RB_INSERT_FIXUP(Tree* &T, Node* z){
	Node* y;

	while(z->parent->color==RED){
		if(z->parent==z->parent->parent->left){     //z节点父节点为其祖父节点的左孩子
			y=z->parent->parent->right;
			if(y->color==RED){                      //case1
				z->parent->color=BLACK;
				y->color=BLACK;
				z->parent->parent->color=RED;
				z=z->parent->parent;
			}
			else{                                       
				if(z==z->parent->right){            //case2
					z=z->parent;
					LEFT_ROTATE(T,z);
				}
				z->parent->color=BLACK;             //case3
				z->parent->parent->color=RED;
				RIGHT_ROTATE(T,z->parent->parent);
			}
		}
		else{									    //z节点父节点为其祖父节点的右孩子
			y=z->parent->parent->left;
			if(y->color==RED){						//case 1
				z->parent->color=BLACK;
				y->color=BLACK;
				z->parent->parent->color=RED;
				z=z->parent->parent;
			}
			else{
				if(z==z->parent->left){            //case2
					z=z->parent;
					RIGHT_ROTATE(T,z);
				}
				z->parent->color=BLACK;             //case3
				z->parent->parent->color=RED;
				LEFT_ROTATE(T,z->parent->parent);
			}
		}
	}
	T->root->color=BLACK;
}

//节点左旋
void LEFT_ROTATE(Tree* &T, Node* x){
	Node* y;

	y=x->right;
	x->right=y->left;
	if(y->left!=T->nil)
		y->left->parent=x;
	y->parent=x->parent;
	if(x->parent==T->nil)
		T->root=y;
	else if(x==x->parent->left)
		x->parent->left=y;
	else
		x->parent->right=y;
	y->left=x;
	x->parent=y;
	//调整max
	x->max=Max(x->left->max,x->right->max,x->Int.high);
	x->parent->max=Max(x->max,x->parent->right->max,x->parent->Int.high);
}

//节点右旋
void RIGHT_ROTATE(Tree* &T, Node* y){
	Node *x;

	x=y->left;
	y->left=x->right;
	if(x->right!=T->nil)
		x->right->parent=y;
	x->parent=y->parent;
	if(y->parent==T->nil)
		T->root=x;
	else if(y==y->parent->left)
		y->parent->left=x;
	else
		y->parent->right=x;
	x->right=y;
	y->parent=x;
	//调整max
	y->max=Max(y->left->max,y->right->max,y->Int.high);
	y->parent->max=Max(y->max, y->parent->Int.high, y->parent->left->max);
}

//前序遍历
void PreOrder(Node* tree,Tree * T){
	map<int,string> color;color[0]="red";color[1]="black";

	if(tree!=T->nil){
		cout << tree->Int.low<< "," << tree->Int.high << "," << tree->max <<","<<color[tree->color]<< endl;
		PreOrder(tree->left, T);
		PreOrder(tree->right,T);
	}
}

//中序遍历
void InOrder(Node* tree,Tree* T){
	map<int,string> color;color[0]="red";color[1]="black";
	if(tree!=T->nil){
		InOrder(tree->left,T);
		cout << tree->Int.low<< "," << tree->Int.high << "," << tree->max << color[tree->color]<< endl;
		InOrder(tree->right,T);
	}
}

//自node节点逐步向根调整max值
void FixMax(Node* node, Tree* T){
	Node *temp;
	
	temp=node;
	while(temp!=T->nil){
		temp->max=Max(temp->left->max, temp->right->max, temp->Int.high);
		temp=temp->parent;
	}
}

//找三个整数a，b，c的最大者
int Max(int a, int b, int c){
	int max;

	max=a;
	if(b>max)
		max=b;
	if(c>max)
		max=c;
	return max;
}

//寻找区间i
Node* INTERVAL_SEARCH(Tree* T, Interval i){
	Node* x;

	x=T->root;
	while(x!=T->nil && !Overlap(x->Int, i)){
		if(x->left!=T->nil && x->left->max>=i.low){
			x=x->left;
		}
		else
			x=x->right;
	}
	return x;
}
//判断两个区间a和b是否重叠
bool Overlap(Interval a, Interval b){
	if(a.high<b.low || a.low>b.high || b.high<a.low || b.low>a.high)//a在b左边,a在b右边,b在a左边,b在a右边
		return false;
	return true;
}

三、算法分析

根据以上实验过程发现设计的查找重叠区间算法能正确的找到重叠区间，并且当查找失败是也能正确显示。另外区间树为在红黑树基础上通过调整节点结构以及插入算法，左旋右旋算法来实现，其中的RB_INSERT_FIXUP算法无须做调整


砺晗
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
区间树上重叠区间查找算法.doc
03-19
区间树上重叠区间查找算法.doc
区间树上的重叠区间查找算法——C++
狒狒不会编程
11-29 1702
区间树上的重叠区间查找算法——C++ 题目： 区间树的构造； 查找算法Interval-Search(T, i)； 算法设计：      步骤一：区间树是在红黑树基础上进行的简单的数据结构扩张。选择一棵红黑树，在每个结点x中加入一个区间属性x.int，设置x的关键字为区间的低端点x.int.low。      步骤二：附加信息。附加的信息为x.max，其值为以x为根的子树中所有区间的端点...
《算法导论》实验七：区间树上的重叠区间查找算法（C++）——控制台树型显示
allin_allin的恋爱小屋
12-15 7429
区间树（interval tree）是一种对动态集合进行维护的扩张红黑树，因此可在实验二红黑树的基础上进行扩张。为此，本实验（实验三）在实验二的基础上对红黑树的节点增加新的附加信息，并设计新的操作。从而熟悉并实现区间树上的重叠区间查找算法，分析该算法的性能。
区间树上重叠区间的查找
最新发布
qq_63564590的博客
03-11 377
在最坏的情况下，如果树是一个完全平衡的二叉搜索树，并且查询区间与树中的所有区间都重叠，那么函数的时间复杂度将是O(n)，其中n是树中节点的数量。将实验三中实现的红黑树插入算法改编为区间树插入算法，并实现重叠区间的查找算法:给定一棵区间树T和一个区间i，在O(min(n, klogn))时间内列出T中所有与i重叠的区间，其中k为重叠的区间数。综上所述，整个函数的时间复杂度为O(log n)，其中n是树中节点的数量,满足实验要求O(min(n,klogn))。若存在结果，输出对应节点区间： [x, y]
区间树上的重叠区间查找算法
Icyfire Talks
01-27 7181
 实验目的：         熟悉并实现区间树上的重叠区间查找算法，分析该算法的性能。问题定义         尝试构造一个区间树。         可依次插入下列数组中的元素：[8,9] [ 5,8] [15,23] [0,3] [6,10] [25,30] [17,19] [26,26] [19,20]查找重叠区间：“find [22,25]”或“find [11,14
算导实验四 区间树上重叠区间查找
yangf257的博客
07-28 1035
区间树的查找算法
贪心算法 || 区间重叠问题
科技编程熊的博客
08-10 1954
题目链接： https://www.51nod.com/Challenge/Problem.html#problemId=1091 题目： X轴上有N条线段，每条线段包括1个起点和终点。线段的重叠是这样来算的，[10 20]和[12 25]的重叠部分为[12 20]。给出N条线段的起点和终点，从中选出2条线段，这两条线段的重叠部分是最长的。输出这个最长的距离。如果没有重叠，输出0。 输入： 第1行...
区间树的重叠区间查找算法
12-17
算法导论，在红黑树的基础上扩张出区间树的数据结构，并且构造区间树的重叠区间查找算法。
区间树查找算法
11-15
区间树上的重叠区间查找算法：构造1000个节点的区间树，查找具有最小低端点的重叠区间。亲测VS可运行，VC不能运行是因为不支持操作符重载。
红黑树与区间树算法实现
04-08
红黑树是一种自平衡二叉查找树，由Rudolf Bayer在1972年提出。它在保持二叉查找树特性的同时，通过添加额外的颜色属性（红色或黑色）来保证树的平衡。以下是红黑树的主要特点和操作： 1. 每个节点要么是红色，要么...
算法导论——所有算法和数据结构的C++实现
01-09
所有代码都是在我学习这本书时亲手敲出来的，并且调试正确了，包括：第三部分到第六部分（即10-26章），外加第七部分31和32章所有的算法和数据结构以及编程习题还有思考题的C++实现源代码； 第一、二部分学习的较早...
贪心算法——重叠区间问题（力扣435 ，452题）
weixin_51818357的博客
12-14 1729
重叠区间 给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。 注意: 可以认为区间的终点总是大于它的起点。 区间 [1,2] 和 [2,3] 的边界相互“接触”，但没有相互重叠。 示例 1: 输入: [ [1,2], [2,3], [3,4], [1,3] ] 输出: 1 解释: 移除 [1,3] 后，剩下的区间没有重叠。 示例 2: 输入: [ [1,2], [1,2], [1,2] ] 输出: 2 解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。 示例 3: 输入: [ [
线段树（区间树）-查询和更新
swadian2008的博客
04-29 2105
一、为什么需要使用线段树 在一个区间内，需要同时实现两个操作：更新+查询，如果我们仅仅使用数组来实现，它的时间复杂度时O(n)级别的，相对来说，如果我们使用线段树，便可以获得更好的时间复杂度和更高的执行效率。 例如，我们需要在一个数组中，求一个区间内的元素的和，如果我们使用数组来进行实现，需要找到数组中所有的这些元素，然后进行一个一个的遍历求和操作，如果数据量很大的化，这种操作时比较低效的...
合并区间：解决区间重叠问题的高效算法
Geek_的博客
09-19 1025
合并区间是一个常见的编程问题，通常需要对区间进行排序并遍历以合并重叠的区间。通过使用合适的数据结构和算法，我们可以高效地解决这个问题。上面的代码演示了一个使用排序和遍历的解决方案，它可以有效地合并区间并返回一个不重叠的结果数组。理解这种问题的解决思路可以帮助你更好地应对类似的区间操作问题。
区间重叠|重叠比判断算法
qq_21478261的博客
11-05 965
假设存在两个区间A[A1 , A2] , B[B1 , B2]，如何判断区间A和B存在重叠，重叠的长度多少。
leetcode——区间重叠问题（贪心算法）&对原始数组排序的思考
weixin_38208912的博客
02-05 2688
区间重叠问题 区域重叠问题是贪心算法常见题目，其类型通常是N×2N×2N×2或者N×MiN×M_{i}N×Mi​的数组，进行一些合并，删除等操作。 常见题型： 合并区间： leetcode 56（合并区间） leetcode 763（先统计，再合并区间） 计算不重叠区间的个数： leetcode 435（不重叠区间个数） leetcode 452（相邻区间视为重叠区间） 合并区间问...
区间重叠判断算法
romandion的专栏
05-10 1万+
一、背景     在一次业务开发中，发现有一种数据，每天都会有一个值，不论是否是节假日。由于这个值的变化频率比较低，导致会有连续的N个日期，值是相同的。于是，就想将这些值合并。比如原来的结构是二元组DATA(Value , Date)，合并成三元组DATA(Value , BeginDate , EndDate)。    合并完原始数据后，生成三元组DATA1，还要和已经存在的三元组DATA2
分支限界法解0-1背包问题
热门推荐
xiaowang627的博客
02-21 2万+
一、   算法设计与分析： （1）假设物品数为n，解空间：{(0,0,…,0),(0,0,…,1),…,(1,1,…,1)}，即为子集树，设计树节点结构如下： struct Node { intvalue; //搜索到该节点时的价值 intweight; //搜索到该节点时的总重量 floatbound;
神书《算法导论》——奠定IT基础的基石
"算法导论-电子书" 《算法导论》是IT领域中一本极其重要的经典著作，被誉为“神书”，对于任何想要深入理解和掌握计算机算法与数据结构的人来说，都是不可或缺的参考书。这本书由Thomas H. Cormen、Charles E. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值