如何构建数据结构以支持某些范围查询

Question

间隔由开始和结束定义。

给定一个范围[例如，0-999] 内的一组可能重叠的区间， 构建数据结构以支持以下范围查询 时间复杂度

.

Overlap(start, end) = 与 [start, end] 重叠的所有区间的集合

Within(start, end) = 位于 [start, end] 内的所有区间的集合

在哪里，

Intervals I1[start1, end1], I2[start2, end2] are said to overlap with  each other iff start1<end2 && start2<end1
Interval I1[start1, end1] is said to be within interval I2[start2,end2] iff start1>start2 && end1<end2

Answer 1

这个问题涉及的数据结构称为Interval tree：

一个有序的树数据结构来保存间隔，它允许一个 有效地找到与任何给定间隔重叠的所有间隔或 点。

两种有效的方法：

• 使用augmented tree
• 使用 Medial- or length-oriented tree

链接中提出的用于搜索所有重叠区间的算法预计会比传统的区间树（增广树）更快地进行搜索操作，添加元素会慢一些。

实现区间树的各种方法：

• Standford 在通用实用程序包 edu.stanford.nlp.util 中有一个 an implementation of IntervalTree ，其中包含许多有用的方法
• Sample code for an interval tree where Given n closed intervals [ai, bi] it finds all pairs of intervals that overlap - Algorithms, 4th Edition
• Another interval tree implementation

在实施解决方案时，您应该知道performance of java collections processing

Answer 2

使用区间树编写了一些 Scala 代码来实现这一点！

class IntervalSearchTree {
     var root=new IntervalNode(null,null,null,null,null);

  class IntervalNode(var left:IntervalNode,var start:Integer,var end:Integer,var maxEnd:Integer,var right:IntervalNode);

    def add(start:Integer,end:Integer ):Unit={
      var node:IntervalNode=root
      while(node!=null){
        if(end>node.maxEnd)
          node.maxEnd=end
        if (start < node.start) {
                if (node.left == null) {
                    node.left = new IntervalNode(null, start, end, end, null);
                    return;
                }
                node = node.left;
            } else {
                if (node.right == null) {
                    node.right = new IntervalNode(null, start, end, end, null);
                    return;
                }
                node = node.right;
            }
      }
      root =  new IntervalNode(null, start, end, end, null);
    }

    def overlap(start:Integer,end:Integer):Unit={

      var intervalNode:IntervalNode=root;
      while (intervalNode != null) {
         if (intersection(start, end, intervalNode)){
           println(intervalNode.start+"-"+intervalNode.end)
         }
         if (leftSubTree(start, end, intervalNode.left)) {
                intervalNode = intervalNode.left;


            } else {

                intervalNode = intervalNode.right;

            }


      }

    }

    def within(start:Integer,end:Integer):Unit={
        var intervalNode:IntervalNode = root;
        while (intervalNode != null) {
           if (subset(start, end, intervalNode)){
           println(intervalNode.start+"-"+intervalNode.end)
         }
         if (leftSubTree(start, end, intervalNode.left)) {
                intervalNode = intervalNode.left;


            } else {

                intervalNode = intervalNode.right;

            }
        }

    }


    def subset(start:Integer,end:Integer,intervalNode:IntervalNode):Boolean={
      return start<intervalNode.start  && end >intervalNode.end ;
    }

    def intersection(start:Integer,end:Integer,intervalNode:IntervalNode):Boolean={
      return start < intervalNode.end && end > intervalNode.start;
    }

    def leftSubTree(start:Integer,end:Integer,intervalLeftSubtree:IntervalNode):Boolean={
      return intervalLeftSubtree != null && intervalLeftSubtree.maxEnd > start;
    }


    def main(args: Array[String]): Unit = {
      var intervalSearchTree=new IntervalSearchTree()
        intervalSearchTree.add(17, 19);
        intervalSearchTree.add(5, 8);
        intervalSearchTree.add(21, 24);
        intervalSearchTree.add(22, 24);
        intervalSearchTree.add(20, 26);
        intervalSearchTree.add(20, 24);
        intervalSearchTree.add(4, 8);
        intervalSearchTree.add(5, 9);
        intervalSearchTree.add(15, 18);
        intervalSearchTree.add(7, 10);
        intervalSearchTree.add(16, 22);

        //Input for testing overlaps 
        println("Overlaps");
        intervalSearchTree.overlap(23, 25);
        //Input for testing overlaps
        println("Within");
        intervalSearchTree.within(4, 25);
    }




}