introduction to algorithms 笔记 interval tree(区间树)

最新推荐文章于 2020-07-24 16:34:11 发布
最新推荐文章于 2020-07-24 16:34:11 发布
阅读量859 收藏
点赞数 1
分类专栏： algorithms 文章标签： tree null delete insert p2p class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yydrewdrew/article/details/2706731
版权

//author:yydrewdrew 

#include <iostream>

using namespace std;
#define max(a,b) (((a) > (b)) ? (a) : (b))
#define ERROR -1

template <class T>
struct IntervalTreeNode
{
 T leftvalue;
 T rightvalue;
 T maxrightvalue;
 IntervalTreeNode *parent;
 IntervalTreeNode *left;
 IntervalTreeNode *right;
 enum Color{R,B};
 Color color;
};


template <class T>
class IntervalTree
{
public:
 void TreeWalk()const;
 IntervalTreeNode<T> *Insert(const T &left,const T &right);
 IntervalTreeNode<T> *Delete(const T &left,const T &right);
 IntervalTreeNode<T> *Serach(const T &left,const T &right)const;
 IntervalTreeNode<T> *Predecesor(const T &left,const T &right)const;
 IntervalTreeNode<T> *Successor(const T &left,const T &right)const;
 IntervalTreeNode<T> *Min()const;
 IntervalTreeNode<T> *Max()const;
 void Clear();
 void Swap(IntervalTree<T> &obj);
public:
 IntervalTree():root(NULL),NIL(new(IntervalTreeNode<T>))
 {
  NIL->leftvalue = 0;
  NIL->left = NULL;
  NIL->right = NULL;
  NIL->maxrightvalue = 0;
  NIL->color = IntervalTreeNode<T>::B;
 }
 IntervalTree<T> &operator = (const IntervalTree<T> &obj);
 IntervalTree<T>(const IntervalTree<T> &obj);
 virtual ~IntervalTree();
private:
 IntervalTree(IntervalTreeNode<T> *r,IntervalTreeNode<T> *nil):root(r),NIL(nil){}
 void LeftRotate(IntervalTreeNode<T> *const p);;
 void RightRotate(IntervalTreeNode<T> *const p);
 void IntervalTreeInsertFixup(IntervalTreeNode<T> *p);
 void IntervalTreeDeleteFixup(IntervalTreeNode<T> *p);
 void Clean()
 {
  root = NULL;
  NIL = NULL;
 }
 void Destory(IntervalTreeNode<T> *p);
 void Scan(IntervalTreeNode<T> *root)const;
 void Copy(IntervalTreeNode<T> *p,const IntervalTree<T> &obj);
 void MaintenanceSize(IntervalTreeNode<T> *p);
 bool IsOverlap(const IntervalTreeNode<T> *p1,IntervalTreeNode<T> *p2)const;
 IntervalTreeNode<T> *Find(const T &left,const T &right)const;
 void MaintenanceMaxrightValue(IntervalTreeNode<T> *p);
private:
 IntervalTreeNode<T> *root;
 IntervalTreeNode<T> *NIL;
};
/
template<class T>
bool IntervalTree<T>::IsOverlap(const IntervalTreeNode<T> *p1,IntervalTreeNode<T> *p2)const
{
 if (p1 == NIL || p2 == NIL)
 {
  return false;
 }
 return(p1->rightvalue >= p2->leftvalue && p1->leftvalue <= p2->rightvalue);
}

template<class T>
void IntervalTree<T>::Swap(IntervalTree<T> &obj)
{
 std::swap(root,obj.root);
 std::swap(NIL,obj.NIL);
 return;
}

template<class T>
IntervalTree<T> &IntervalTree<T>::operator = (const IntervalTree<T> &obj)
{
 if (this != &obj)
 {
  Swap(IntervalTree<T>(obj));
 }
 return *this;
}

template<class T>
void IntervalTree<T>::Copy(IntervalTreeNode<T> *p,const IntervalTree<T> &obj)
{
 if (p != obj.NIL)
 {
  Copy(p->left,obj);
  Insert(p->leftvalue,p->rightvalue);
  Copy(p->right,obj);
 }
 return;
}
///
template<class T>
IntervalTree<T>::IntervalTree(const IntervalTree<T> &obj)
{
 root = NULL;
 NIL = new IntervalTreeNode<T>;
 NIL->leftvalue = 0;
 NIL->rightvalue = 0;
 NIL->maxrightvalue = 0;
 NIL->left = NULL;
 NIL->right = NULL;
 NIL->color = IntervalTreeNode<T>::B;
 Copy(obj.root,obj);
}
///
template<class T>
void IntervalTree<T>::Scan(IntervalTreeNode<T> *root)const
{
 if (root == NULL || root == NIL)
 {
  return;
 }
 Scan(root->left);
 std::cout << root->leftvalue << "   " << root->rightvalue << std::endl;
 Scan(root->right);
}
/
template<class T>
void IntervalTree<T>::TreeWalk()const
{
 Scan(root);
}
///
template<class T>
IntervalTreeNode<T> *IntervalTree<T>::Min()const
{
 if (root == NULL)
 {
  return NULL;
 }
 IntervalTreeNode<T> *p = root;
 IntervalTreeNode<T> *p2 = NULL;
 while (p != NIL)
 {
  p2 = p;
  p = p->left;
 }
 return p2;
}
//
template<class T>
IntervalTreeNode<T> *IntervalTree<T>::Max()const
{
 if (root == NULL)
 {
  return NULL;
 }
 IntervalTreeNode<T> *p = root;
 IntervalTreeNode<T> *p2 = NULL;
 while (p != NIL)
 {
  p2 = p;
  p = p->right;
 }
 return p2;
}
///
template<class T>
IntervalTreeNode<T> *IntervalTree<T>::Find(const T &left,const T &right)const
{
 if (root == NULL)
 {
  return NULL;
 }
 IntervalTreeNode<T> *p = root;
 while (p != NIL && !(left == p->leftvalue && right == p->rightvalue))
 {
  if (p->left->maxrightvalue > left)
  {
   p = p->left;
  }
  else
  {
   p = p->right;
  }
 }
 return p;
}
//
template<class T>
IntervalTreeNode<T> *IntervalTree<T>::Serach(const T &left,const T &right)const
{
 if (root == NULL)
 {
  return NULL;
 }
 IntervalTreeNode<T> *p = root;
 IntervalTreeNode<T> tem = {left,right};
 while (p != NIL && !IsOverlap(p,&tem))
 {
  if (p->left->maxrightvalue > left)
  {
   p = p->left;
  }
  else
  {
   p = p->right;
  }
 }
 return p;
}
/
template<class T>
IntervalTreeNode<T> *IntervalTree<T>::Successor(const T &left,const T &right)const
{
 IntervalTreeNode<T> *p = Serach(left,right);
 if (p->right != NIL)
 {
  IntervalTree<T> treetem(p->right,NIL);
  p = treetem.Min();
  treetem.Clean();
  return p;
 }
 IntervalTreeNode<T> *p2 = p->parent;
 while (p2 != NIL && p == p2->right)
 {
  p = p2;
  p2 = p2->parent;
 }
 return p2;
}

template<class T>
IntervalTreeNode<T> *IntervalTree<T>::Predecesor(const T &left,const T &right)const
{
 IntervalTreeNode<T> *p = Serach(t);
 if (p->left != NIL)
 {
  IntervalTree<T> treetem(p->left,NIL);
  p = treetem.Max();
  treetem.Clean();
  return p;
 }
 IntervalTreeNode<T> *p2 = p->parent;
 while (p2 != NIL && p == p2->left)
 {
  p = p2;
  p2 = p2->parent;
 }
 return p2;
}
//
template<class T>
void IntervalTree<T>::LeftRotate(IntervalTreeNode<T> *const p)
{
 if (p == NULL || p == NIL)
 {
  return;
 }
 if(p->right == NIL)
 {
  return;
 }
 IntervalTreeNode<T> *p2 = p->right;
 p2->parent = p->parent;
 if (p->parent != NIL)
 {
  if (p == p->parent->left)
  {
   p->parent->left = p2;
  }
  else
  {
   p->parent->right = p2;
  }
 }
 if (p2->left != NIL)
 {
  p2->left->parent = p;
 }
 p->right = p2->left;
 p2->left = p;
 p->parent = p2;
 p->maxrightvalue = max(max(p->left->maxrightvalue,p->right->maxrightvalue),p->rightvalue);
 p2->maxrightvalue = max(max(p2->left->maxrightvalue,p2->right->maxrightvalue),p2->rightvalue);
 return;
}
///
template<class T>
void IntervalTree<T>::RightRotate(IntervalTreeNode<T> *const p)
{
 if (p == NULL || p == NIL)
 {
  return;
 }
 if (p->left == NIL)
 {
  return;
 }
 IntervalTreeNode<T> *p2 = p->left;
 if (p2->right != NIL)
 {
  p2->right->parent = p;
 }
 p->left = p2->right;
 p2->parent = p->parent;
 if (p->parent != NIL)
 {
  if (p == p->parent->left)
  {
   p->parent->left = p2;
  }
  else
  {
   p->parent->right = p2;
  }
 }
 p->parent = p2;
 p2->right = p;
 p->maxrightvalue = max(max(p->left->maxrightvalue,p->right->maxrightvalue),p->rightvalue);
 p2->maxrightvalue = max(max(p2->left->maxrightvalue,p2->right->maxrightvalue),p2->maxrightvalue);
 return;
}
///
template<class T>
void IntervalTree<T>::MaintenanceMaxrightValue(IntervalTreeNode<T> *p)
{
 while (p != NIL)
 {
  p->maxrightvalue = max(max(p->left->maxrightvalue,p->right->maxrightvalue),p->maxrightvalue);
  p = p->parent;
 }
 return;
}
///
template<class T>
IntervalTreeNode<T> *IntervalTree<T>::Insert(const T &left,const T &right)
{
 if (left > right)
 {
  throw ERROR;
 }
 IntervalTreeNode<T> *p = root;
 IntervalTreeNode<T> *p2 = NULL;
 while (p != NIL && p != NULL)
 {
  p2 = p;
  if (left > p->leftvalue)
  {
   p = p->right;
  }
  else
  {
   p = p->left;
  }
 }
 IntervalTreeNode<T> *ptem = new IntervalTreeNode<T>;
 ptem->leftvalue = left;
 ptem->rightvalue = right;
 ptem->maxrightvalue = ptem->rightvalue;
 ptem->left = NIL;
 ptem->right = NIL;
 if (p == NULL)
 {
  root = ptem;
  root->color = IntervalTreeNode<T>::B;
  root->parent = NIL;
 }
 else
 {
  if (left > p2->leftvalue)
  {
   p2->right = ptem;
   ptem->color = IntervalTreeNode<T>::R;
   ptem->parent = p2;
  }
  else
  {
   p2->left = ptem;
   ptem->color = IntervalTreeNode<T>::R;
   ptem->parent = p2;
  }
 }
 MaintenanceMaxrightValue(ptem);
 IntervalTreeInsertFixup(ptem);
 return ptem;
}

template<class T>
void IntervalTree<T>::IntervalTreeInsertFixup(IntervalTreeNode<T> *p)
{
 while (p->parent->color == IntervalTreeNode<T>::R)
 {
  if (p->parent == p->parent->parent->left)
  {
   IntervalTreeNode<T> *y = p->parent->parent->right;
   if (y->color == IntervalTreeNode<T>::R)
   {
    p->color = IntervalTreeNode<T>::B;
    y->color = IntervalTreeNode<T>::B;
    p->parent->parent->color = IntervalTreeNode<T>::R;
    p = p->parent;
   }
   else if (p == p->parent->right)
   {
    p = p->parent;
    LeftRotate(p);
   }
   p->parent->color = IntervalTreeNode<T>::B;
   p->parent->parent->color = IntervalTreeNode<T>::R;
   RightRotate(p);
  }
  else
  {
   IntervalTreeNode<T> *y = p->parent->parent->left;
   if (y->color == IntervalTreeNode<T>::R)
   {
    p->color = IntervalTreeNode<T>::B;
    y->color = IntervalTreeNode<T>::B;
    p->parent->parent->color = IntervalTreeNode<T>::R;
    p = p->parent;
   }
   else if (p == p->parent->left)
   {
    p = p->parent;
    RightRotate(p);
   }
   p->parent->color = IntervalTreeNode<T>::B;
   p->parent->parent->color = IntervalTreeNode<T>::R;
   LeftRotate(p);
  }
 }
 root->color = IntervalTreeNode<T>::B;
 return;
}
///
template<class T>
IntervalTreeNode<T> *IntervalTree<T>::Delete(const T &left,const T &right)
{
 IntervalTreeNode<T> *p = Find(left,right);
 if (p == NULL)
 {
  return NIL;
 }
 IntervalTreeNode<T> *p2 = p;
 if (p->left != NIL && p->right !=NIL)
 {
  p2 = Successor(left,right);
  if (p2->parent == NIL)
  {
   root = p2->right;
   p2->right->parent = root;
  }
  else
  {
   if (p2 == p2->parent->left)
   {
    p2->parent->left = p2->right;
   }
   else
   {
    p2->parent->right = p2->right;
   }
  }
  p2->right->parent = p2->parent;
  std::swap(p->leftvalue,p2->leftvalue);
  std::swap(p->rightvalue,p2->rightvalue);
  p->maxrightvalue = max(max(p->left->maxrightvalue,p->right->maxrightvalue),p->rightvalue);
  p2->maxrightvalue = max(max(p2->left->maxrightvalue,p2->right->maxrightvalue),p->maxrightvalue);
  p = p2;  
  p2 = p2->right;
 }
 else
 {
  if (p->left != NIL && p->right == NIL)
  {
   if (p->parent == NIL)
   {
    root = p->left;
    p->left->parent = NIL;
   } 
   else if (p == p->parent->left)
   {
    p->parent->left = p->left;
    p->left->parent = p->parent;
   }
   else
   {
    p->parent->right = p->left;
    p->left->parent = p->right;
   }
   p2 = p->left;
  }
  else if (p->left == NIL && p->right != NIL)
  {
   if (p->parent == NIL)
   {
    root = p->right;
    p->right->parent = NIL;
   }
   else if (p == p->parent->left)
   {
    p->parent->left = p->right;
    p->right->parent = p->parent;
   }
   else
   {
    p->parent->right = p->right;
    p->right->parent = p->parent;
   }
   p2 = p->right;
  }
  else
  {
   if (p->parent == NIL)
   {
    root = NULL;
   }
   else if (p == p->parent->left)
   {
    p->parent->left = NIL;
   }
   else
   {
    p->parent->right = NIL;
   }
   p2 = p->right;
  }
 }
 MaintenanceMaxrightValue(p2);
 if (p->color == IntervalTreeNode<T>::B)
 {
  IntervalTreeDeleteFixup(p2);
 }
 return p;
}
//
template<class T>
void IntervalTree<T>::IntervalTreeDeleteFixup(IntervalTreeNode<T> *x)
{
 if (root == NULL)
 {
  return;
 }
 while (x != root && x->color == IntervalTreeNode<T>::B)
 {
  if (x == x->parent->left)
  {
   IntervalTreeNode<T> *w = x->parent->right;
   if (w->color == IntervalTreeNode<T>::R)
   {
    w->color = IntervalTreeNode<T>::B;
    LeftRotate(x->parent);
    w = x->parent->right;
   }
   if (w->left->color == IntervalTreeNode<T>::B && w->right->color == IntervalTreeNode<T>::B)
   {
    w->color = IntervalTreeNode<T>::R;
    x = x->parent;
   }
   else if (w->right->color == IntervalTreeNode<T>::B)
   {
    w->left->color = IntervalTreeNode<T>::B;
    w->color = IntervalTreeNode<T>::R;
    RightRotate(w);
    w = x->right->right;
    w->color = x->parent->color;
    x->parent->color = IntervalTreeNode<T>::B;
    w->right->color = IntervalTreeNode<T>::B;
    LeftRotate(x->parent);
    x = root;
   }
  }
  else
  {
   IntervalTreeNode<T> *w = x->parent->left;
   if (w->color == IntervalTreeNode<T>::R)
   {
    w->color = IntervalTreeNode<T>::B;
    RightRotate(x->parent);
    w = x->parent->left;
   }
   if (w->right->color == IntervalTreeNode<T>::B && w->left->color == IntervalTreeNode<T>::B)
   {
    w->color = IntervalTreeNode<T>::R;
    x = x->parent;
   }
   else if (w->left->color == IntervalTreeNode<T>::B)
   {
    w->right->color = IntervalTreeNode<T>::B;
    w->color = IntervalTreeNode<T>::R;
    LeftRotate(w);
    w = x->parent->left;
    w->color = x->parent->color;
    x->parent->color = IntervalTreeNode<T>::B;
    w->left->color = IntervalTreeNode<T>::B;
    RightRotate(x->parent);
    x = root;
   }
  }
  x->color = IntervalTreeNode<T>::B;
 }
}

template<class T>
void IntervalTree<T>::Clear()
{
 if (root != NULL)
 {
  Destory(root);
  root = NULL;
 }
 return;
}
//
template<class T>
void IntervalTree<T>::Destory(IntervalTreeNode<T> *p)
{
 while (p != NIL)
 {
  Destory(p->left);
  Destory(p->right);
  delete p;
  p = NIL;
 }
 return;
}

template<class T>
IntervalTree<T>::~IntervalTree()
{
 Clear();
 if (NIL != NULL)
 {
  delete NIL;
 }
}

yydrewdrew
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
扩充的数据结构-区间树interval-tree
borderLands
07-24 515
（1）区间树所存的value为一个区间interval，其key值为interval的low值（即左值，由于树有左右节点，interval由low,high决定，避免混淆） （2）区间树还储存某节点 x 的所有子节点中最大值m，即m = m[x], or m = m[x->left], or m = m[x->right. m所带来的modifier操作的修改： 旋转操作：pnode
INTERVAL_tree
03-17
算法和数据结构，扩展二叉树的重要应用，实现区间树，c++
Interval Tree
AlgorithmEngine
06-26 518
TO DO http://www.careercup.com/question?id=14045672
interval tree代码阅读
键盘侠
08-18 612
princeton 算法课中讲到interval tree，但没有具体讲实现。
[算法系列之二十三]线段树（Interval Tree）
SmartSi
02-25 579
一 背景 在信息学竞赛中，我们经常会碰到一些跟区间有关的问题，比如给一些区 间线段求并区间的长度，或者并区间的个数等等。这些问题的描述都非常简单，但是通常情况下数据范围会非常大，而朴素方法的时间复杂度过高，导致不能在规定时间内得到问题的解。这时，我们需要一种高效的数据结构来处理这样的问题，在本文中，我们介绍一种基于分治思想的数据结构—-线段树。 二 简介 线段树是一种二叉树形结构，属于平...
Introduction to Algorithms Third Edition
05-16
Series: MIT Press Hardcover: 1312 pages Publisher: The MIT Press; 3rd edition (July 31, 2009) Language: English ISBN-10: 0262033844 ISBN-13: 978-0262033848
Introduction to algorithms THIRD EDITION
06-27
这本书堪称是搞程序开发的经典之作，要想成为一名合格的程序员，必须学习数据结构，而这本书会带领你彻底搞明白什么才是一个好的算法。
算法导论 Introduction to Algorithms Third Edition
04-15
算法导论. Introduction to Algorithms International Edition
Introduction to algorithms A creative approach (Udi Manber)
02-20
如果说算法导论讲的是有哪些算法，那么算法引论讲的就是如何创造算法。 本书是国际算法大师乌迪·曼博（Udi Manber）博士撰写的一本享有盛誉的著作。全书共分12章：第1章到第4章为介绍性内容，涉及数学归纳法、算法...
区间树简单实现（interval_tree）
hubi0952的专栏
10-09 5563
interval_tree.cpp /* 区间树（interval tree）是一种对动态集合进行维护的扩张红黑树，因此可在实验二红黑树的基础上进行扩张。 */ #include #include #include #include #include #include #define SENTINEL -100000 //哨兵，作为nil结点的key，方便树状输出时临
Introduction to Algorithms, Third Edition（算法导论原书英文第三版）
08-07
Introduction to Algorithms, Third Edition（算法导论）
获取时间间隔内的数据库数据_数据结构中的间隔树
cumtv80668的专栏
07-24 417
获取时间间隔内的数据库数据 间隔树 (Interval Tree) Interval tree is a Red-black Tree in which each node has an interval represented by an ordered pair [t1, t2] such that t1 < t2. 间隔树是一棵 红黑树 ，其中每个节点都有一个由有序对[t1，t2]表...
linux中的优先搜索树的实现--prio_tree
Netfilter
06-28 7665
<br />prio_tree在linux内核中被应用于反向内存映射，prio-tree是一棵查找树，它查找的是一个区间，为何将之组织成tree是一个数学问题，简单理解就是根节点包含了所有的区间，父节点代表的区间包含了子节点代表的区间，这里的包含不是现实意义的包含，而是heap/radix意义上的包含，只要满足heap的性质以及radix的性质即可，不过大多数情况下包含的意义就是现实意义的包含，Documentation中的prio_tree.txt中的图示可以看一下，[4,3,7]是[5,2,7]和[6,
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]，范...
rbtree 红黑树的 C 语言实现
jhkwei的专栏
01-18 1243
rbtree 红黑树的 C 语言实现，主要是照搬了《算法导论》，红黑树是一种比较有实用意义的平衡树，不过也挻复杂，主要是利用其它兄弟节点再加以旋转来实现平衡，不过在并发上增删操作不太方便，这时用 skip list 跳跃表有一定的优势。不过用来实现key-->value 数据结构 map , dictation, set 还是不错，现在把源码和测试表如下：/* * rbtree.h * *
线段树模版[interval tree][区间更新]
mars167的博客
03-09 267
这是线段树带区间更新的模版，用结构体实现的。
区间 (interval)
x_flyx的博客
07-27 358
链接：https://www.nowcoder.com/acm/contest/135/I 来源：牛客网   题目描述     Apojacsleam喜欢数组。     他现在有一个n个元素的数组a，而他要对a[L]-a[R]进行M次操作：         操作一：将a[L]-a[R]内的元素都加上P         操作二：将a[L]-a[R]内的元素都减去P     最后询问a[l...
Python Interval库简单用法
有问题请直接说问题就好
01-04 8108
Python Interval库简单用法
线段树入门、总结 Interval Tree
Ac Dream
01-20 3100
线段树入门级总结 By Jsn1993 最近学习了线段树这一种数据结构，也做了不少关于线段树的入门级题目，大致对线段树有 了一个了解。稍稍总结一下（文字没有参考别人的成分）。 一、 初识线段树 1、 称谓及意义 线段树我习惯用英文称呼它（Interval Tree）。Interval 代表区间，恰恰说明了线段树是一种基 于区间的数据结构。 2、 线段树的表示 线段树是一棵二叉树，
introduction to algorithms 3rd
最新发布
09-06
《算法导论》（Introduction to Algorithms）是由Thomas H. Cormen、Charles E. Leiserson、Ronald L. Rivest和Clifford Stein等人合著的一本计算机科学领域经典教材。该书首次出版于1990年，目前已经发行至第三版。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值