区间树上重叠区间的查找

于 2024-03-11 22:00:15 发布
阅读量416 收藏 9
点赞数 9
分类专栏： 算法基础 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63564590/article/details/136636637
版权

文章目录

实验内容

对红黑树进行修改，使其成为一颗区间数，并实现区间树上的重叠区间查找算法。程序输入：
1、生成区间树
文件名： insert.txt
文件格式：第一行为待插入数据的个数，第二行之后每一行表示一个区间
注：
1）初始时树应为空。
2）按顺序插入。
2、待查询区间应由控制台输入，且由控制台直接打印查找结果(可支持多次查询)：
若存在结果，输出对应节点区间： [x, y]
若无结果，输出: nil

实验目的

将实验三中实现的红黑树插入算法改编为区间树插入算法，并实现重叠区间的查找算法:给定一棵区间树T和一个区间i，在O(min(n, klogn))时间内列出T中所有与i重叠的区间，其中k为重叠的区间数。

区间树的数据结构

对原有的红黑树的数据结构进行修改，区间树的数据结构如下：

struct interval
{
    int low;
    int high;
};

struct Node
{
    interval inte;
    int max; // 存储以该节点为根的子树中的最大值
    Color color;
    Node* parent;
    Node* left;
    Node* right;
};

struct Tree
{
    Node* root;
    Node* nil;
};

在结点即“Node”中增加了一个新定义的结构体“interval”即区间，还增加了一个int型变量“max”，用于存储以该结点为根的子树中的最大值。删除了变量“key”。

源码及注释

#include <iostream>
#include <vector>
#include <fstream>
using namespace std;

enum Color { RED, BLACK };

int NIL=0;

struct interval
{
    int low;
    int high;
};

struct Node
{
	Node(interval inte){
			this->inte=inte;
		}
    interval inte;
    int max; // 存储以该节点为根的子树中的最大值
    Color color;
    Node* parent;
    Node* left;
    Node* right;
};

struct Tree
{
    Node* root;
    Node* nil;
};

void LEFT_ROTATE(Tree* &T, Node* x)
{
    Node* 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;

    // 更新节点的最大值
    x->max = max(max(x->left->max, x->right->max), x->inte.high);
    y->max = max(max(y->left->max, y->right->max), y->inte.high);
}

void RIGHT_ROTATE(Tree* &T, Node* x)
{
    Node* y = x->left;
    x->left = y->right;
    if (y->right != T->nil)
        y->right->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->right = x;
    x->parent = y;

    // 更新节点的最大值
    x->max = max(max(x->left->max, x->right->max), x->inte.high);
    y->max = max(max(y->left->max, y->right->max), y->inte.high);
}

void RB_INSERT_FIXUP(Tree* &T, Node* z)
{
    while (z->parent->color == RED)
    {
        if (z->parent == z->parent->parent->left)
        {
            Node* y = z->parent->parent->right;
            if (y->color == RED)
            {
                z->parent->color = BLACK;
                y->color = BLACK;
                z->parent->parent->color = RED;
                z = z->parent->parent;
            }
            else
            {
                if (z == z->parent->right)
                {
                    z = z->parent;
                    LEFT_ROTATE(T, z);
                }
                z->parent->color = BLACK;
                z->parent->parent->color = RED;
                RIGHT_ROTATE(T, z->parent->parent);
            }
        }
        else
        {
            Node* y = z->parent->parent->left;
            if (y->color == RED)
            {
                z->parent->color = BLACK;
                y->color = BLACK;
                z->parent->parent->color = RED;
                z = z->parent->parent;
            }
            else
            {
                if (z == z->parent->left)
                {
                    z = z->parent;
                    RIGHT_ROTATE(T, z);
                }
                z->parent->color = BLACK;
                z->parent->parent->color = RED;
                LEFT_ROTATE(T, z->parent->parent);
            }
        }
    }
    T->root->color = BLACK;
}

void RB_INSERT(Tree* &T, Node* z)
{
    Node* y = T->nil;
    Node* x = T->root;
    while (x != T->nil)
    {
        y = x;
        if (z->inte.low < x->inte.low)
            x = x->left;
        else
            x = x->right;
    }
    z->parent = y;
    if (y == T->nil)
        T->root = z;
    else if (z->inte.low < y->inte.low)
        y->left = z;
    else
        y->right = z;
    z->left = T->nil;
    z->right = T->nil;
    z->color = RED;
    // 更新节点的最大值
    z->max = z->inte.high;
    Node* p = z->parent;
    while (p != T->nil)
    {
        p->max = max(max(p->left->max, p->right->max), p->inte.high);
        p = p->parent;
    }
    RB_INSERT_FIXUP(T, z);
}

// 中序遍历
void InOrder(Node* x, Tree* T)
{
    if (x != T->nil)
    {
        InOrder(x->left, T);
        cout << "[" << x->inte.low << "," << x->inte.high << "] ";
        InOrder(x->right, T);
    }
}


// 更新节点的最大值
void UPDATE_MAX(Node* x)
{
    if (x->left != nullptr && x->right != nullptr)
        x->max = max(max(x->left->max, x->right->max), x->inte.high);
    else if (x->left != nullptr)
        x->max = max(x->left->max, x->inte.high);
    else if (x->right != nullptr)
        x->max = max(x->right->max, x->inte.high);
    else
        x->max = x->inte.high;
}

// 更新节点的最大值（递归）
void UPDATE_MAX_RECURSIVE(Node* x)
{
    if (x == nullptr)
        return;
    UPDATE_MAX_RECURSIVE(x->left);
    UPDATE_MAX_RECURSIVE(x->right);
    UPDATE_MAX(x);
}


bool Overlap(interval a, interval b)
{
    return (a.low <= b.high && b.low <= a.high);
}

vector<interval> IntervalsSearch(Node* node, Tree* T, interval query)
{
    vector<interval> result;

    if (node == T->nil)
        return result;

    if (Overlap(node->inte, query)){
		NIL = 1;
        result.push_back(node->inte);
    }

    if (node->left != T->nil && node->left->max >= query.low)
    {
        vector<interval> leftResult = IntervalsSearch(node->left, T, query);
        result.insert(result.end(), leftResult.begin(), leftResult.end());
    }

    if (node->right != T->nil && node->right->max >= query.low && node->inte.low <= query.high)
    {
        vector<interval> rightResult = IntervalsSearch(node->right, T, query);
        result.insert(result.end(), rightResult.begin(), rightResult.end());
    }

    return result;
}

int main()
{
    Tree* T = new Tree;
    interval ii;
    ii.high = 0;
    ii.low = 0;
    T->nil = new Node(ii);
    T->nil->color = BLACK;
    T->nil->left = nullptr;
    T->nil->right = nullptr;
    T->root = T->nil;
/*
    int num;
    cout << "请输入区间数目：";
    cin >> num;

    vector<vector<int>> arr(num, vector<int>(2));
    for (int i = 0; i < num; i++)
    {
        cout << "请输入第" << i + 1 << "个区间的起始值和结束值：";
        cin >> arr[i][0] >> arr[i][1];
    }
*/

	ifstream file("insert.txt");
		int num;
		file >> num;
		Node* z[num];
		vector<vector<int>> arr(num, vector<int>(2));
	 	for (int i = 0; i < num; i++) 
		{
		 	file >> arr[i][0] >> arr[i][1];
		}
		file.close();

    for (int i = 0; i < num; i++)
    {
        interval inter;
        inter.low = arr[i][0];
        inter.high = arr[i][1];
        z[i]=new Node(inter);
        RB_INSERT(T, z[i]);
        //INTERVAL_INSERT(T, inte);
    }

	
	
    cout << "中序遍历：" << endl;
    InOrder(T->root, T);
    cout << endl;
    
    char continue_flag = 'y';
	while(continue_flag == 'y' || continue_flag == 'Y'){
    	interval query;
    	cout << "请输入要查询的区间的起始值和结束值：";
    	cin >> query.low >> query.high;

    	cout << "与查询区间重叠的区间：" << endl;
    	vector<interval> result = IntervalsSearch(T->root, T, query);
    	for (const auto& interval : result)
    	{
        	cout << "[" << interval.low << "," << interval.high << "]" << endl;
    	}
    	if(NIL == 0) printf("NIL\n");
    	NIL = 0;
    	continue_flag = ' ';
    	while(continue_flag != 'y' && continue_flag != 'Y'&& continue_flag != 'n'&& continue_flag != 'N'){
			cout << "是否继续查询？[y/n]"<<endl;
			cin >>  continue_flag;
		}
	}
    // 释放内存
    delete T->nil;
    delete T;

    return 0;
}

时间复杂度分析

搜索的核心代码如下：

vector<interval> IntervalsSearch(Node* node, Tree* T, interval query)
{
    vector<interval> result;

    if (node == T->nil)
        return result;

    if (Overlap(node->inte, query)){
		NIL = 1;
        result.push_back(node->inte);
    }

    if (node->left != T->nil && node->left->max >= query.low)
    {
        vector<interval> leftResult = IntervalsSearch(node->left, T, query);
        result.insert(result.end(), leftResult.begin(), leftResult.end());
    }

    if (node->right != T->nil && node->right->max >= query.low && node->inte.low <= query.high)
    {
        vector<interval> rightResult = IntervalsSearch(node->right, T, query);
        result.insert(result.end(), rightResult.begin(), rightResult.end());
    }

    return result;
}

时间复杂度分析：

  1. 如果node为空节点（即指向T->nil），则直接返回空的结果数组result。时间复杂度为O(1)。

  2. 如果node与查询区间query重叠（使用Overlap()函数判断），则将node->inte添加到结果数组result中。时间复杂度为O(1)。

  3. 如果node的左子节点不为空且其最大值大于等于查询区间的最小值query.low，则递归调用IntervalsSearch()函数在左子树中搜索重叠的区间，并将结果添加到结果数组result中。递归调用的次数取决于树的高度，因此时间复杂度为O(log n)，其中n是树中节点的数量。

  4. 如果node的右子节点不为空且其最大值大于等于查询区间的最小值query.low且其最小值小于等于查询区间的最大值query.high，则递归调用IntervalsSearch()函数在右子树中搜索重叠的区间，并将结果添加到结果数组result中。递归调用的次数取决于树的高度，因此时间复杂度为O(log n)，其中n是树中节点的数量。

  5. 在最坏的情况下，如果树是一个完全平衡的二叉搜索树，并且查询区间与树中的所有区间都重叠，那么函数的时间复杂度将是O(n)，其中n是树中节点的数量。这是因为在这种情况下，函数将递归地访问树中的每个节点，并将其区间添加到结果数组中。

综上所述，整个函数的时间复杂度为O(log n)，其中n是树中节点的数量,满足实验要求O(min(n,klogn))。

Darcen289
关注
专栏目录
区间树上的重叠区间查找算法
Icyfire Talks
01-27 7208
 实验目的：         熟悉并实现区间树上的重叠区间查找算法，分析该算法的性能。问题定义         尝试构造一个区间树。         可依次插入下列数组中的元素：[8,9] [ 5,8] [15,23] [0,3] [6,10] [25,30] [17,19] [26,26] [19,20]查找重叠区间：“find [22,25]”或“find [11,14
区间树上重叠区间查找
12-05
区间树上重叠区间查找 本次试验是在红黑树的基础上扩展数据结构
区间树的重叠区间查找算法
12-17
算法导论，在红黑树的基础上扩张出区间树的数据结构，并且构造区间树的重叠区间查找算法。
算导实验四 区间树上重叠区间查找
yangf257的博客
07-28 1089
区间树的查找算法
算法导论——区间树上的重叠区间查找算法
xiaowang627的博客
02-17 2148
一、   算法设计与分析： （1）   数据结构设计： //区间 struct Interval{ int low; int high; }; //节点 struct Node{ Node(int low,int high){ this->key=low; this->Int.low=low; this
区间树上重叠区间查找算法.doc
03-19
区间树上重叠区间查找算法.doc
区间树上的重叠区间查找算法源代码和实验报告
04-29
在这个场景下，"重叠区间查找算法"是指在一组区间中找出与给定区间有重叠的区间集合。区间树通过分割区间并将其存储在二叉树结构中，允许我们在对数时间复杂度内执行插入、删除和查询操作，对于处理大量区间数据尤为...
区间树上的重叠区间查找算法——C++
狒狒不会编程
11-29 1748
区间树上的重叠区间查找算法——C++ 题目： 区间树的构造； 查找算法Interval-Search(T, i)； 算法设计：      步骤一：区间树是在红黑树基础上进行的简单的数据结构扩张。选择一棵红黑树，在每个结点x中加入一个区间属性x.int，设置x的关键字为区间的低端点x.int.low。      步骤二：附加信息。附加的信息为x.max，其值为以x为根的子树中所有区间的端点...
《算法导论》14.3 区间树
Toby的博客
09-14 732
本文为《算法导论》14.3 区间树的笔记，欢迎参考！
区间树查找区间算法的实现
04-17
区间树查找区间算法的实现，VC++实现，自动随机生成区间，查找最小区间和调度区间
区间树查询算法实现
03-18
截窗查询是对二维或三维空间中特定区域内的线段、多边形、曲线等进行分析处理的查询技术，是计算几何在诸如地理信息系统、计算机辅助设计、计算机辅助制造等领域广泛应用的重要方法。本文讨论的区间树查询算法，是在平面内线段均与坐标轴平行的理想的情况下，采用几何分析的方法，通过构造空间复杂度为O(n)的便于搜索的区间树，能够在O(log n + k)(k为所有报告出的线段数量）的时间内，完成与坐标轴平行线段对垂直线段区间的查询。
算法导论34--区间树（Python）
勇气与行动
05-29 1650
区间树： 闭区间是一个实数的有序对[t1, t2]，其中t1 我们可以把一个区间[t1, t2]表示成一个对象i。其中属性i.low=t1为低端点，属性i.high=t2为高端点。 区间i和i'重叠：i.low 区间树是一种动态集合进行维护的红黑树，其中每个元素x都包含一个区间x.int。 每个结点x:包含一个区间属性x.int。且x的关键字为区间的低端点
线段树/区间树（java实现版详解附leetcode例题）
最新发布
xiaoliii0401的博客
12-23 1892
你还不太会线段树吗？看了这篇就会了。
区间重叠判断算法
热门推荐
romandion的专栏
05-10 1万+
一、背景     在一次业务开发中，发现有一种数据，每天都会有一个值，不论是否是节假日。由于这个值的变化频率比较低，导致会有连续的N个日期，值是相同的。于是，就想将这些值合并。比如原来的结构是二元组DATA(Value , Date)，合并成三元组DATA(Value , BeginDate , EndDate)。    合并完原始数据后，生成三元组DATA1，还要和已经存在的三元组DATA2
判断两个区间是否存在重叠交叉
Showay 的博客
03-01 6079
转载自：js/java判断两个区间是否存在重叠交叉 假设存在两个区间：区间A、区间B。那么重叠的情况有4种：两种相交，两种包含。如图： 而不重叠的情况有2种：A在B前；B在A前。如图： 得出是否重叠的判断方法： 　重叠：满足 max(A.start, B.start) <= min(A.end, B.end) 不重叠：满足 A.end< B.start ...
区间重叠计算及IntervalTree初识
weixin_30664615的博客
06-14 411
最近被人问到这样一个问题的解决方案：在一个餐馆的预定系统中，接受用户在未来任意一段时间内的预订用餐，用户在预订的时候需要提供用餐的开始时间和结束，餐馆的餐桌是用限的，问题是，系统要在最快的时间段计算出在该用户预定的时间段内是否还有可用的餐桌？其实类似的问题我们在做系统时经常碰到，比如在一个“任务管理”系统中，我们要知道某个任务的执行时间段是否跟已知的时间段有重叠，揭开这些特定需求的外表，...
区间树
zhanglei8893的专栏
06-09 1万+
区间树是在红黑树基础上进行扩展得到的支持以区间为元素的动态集合的操作，其中每个节点的关键值是区间的左端点。通过建立这种特定的结构，可是使区间的元素的查找和插入都可以在O(lgn)的时间内完成。     相比于基础的数据结构，增加了一个max[x]，即以x为根的子树中所有区间的断点的最大值。区间树如下图所示：       这里的区间查找的并不是精确查找，而是查找和给定区间重叠的元素，重叠的
【13】红黑树、并查集
Flippped的博客
07-31 346
红黑树、并查集
C++实现区间树查询操作
"区间树是一种数据结构，常用于高效地处理区间查询问题。这个实验是基于C++实现的，参考了《算法导论》中的描述，并在红黑树的基础上进行了改造。区间树通过红黑树的特性保持了数据的平衡性，确保查询效率。代码已经...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值