From 200d28f9c08355ea3a1b59cd174b6fa95a596358 Mon Sep 17 00:00:00 2001 From: komal Date: Sun, 28 Feb 2021 20:04:51 +0530 Subject: [PATCH] feature:Added IntervalTree DataStructure --- pydatastructs/trees/__init__.py | 9 +- pydatastructs/trees/intervaltree.py | 322 ++++++++++++++++++ .../trees/tests/test_intervaltree.py | 22 ++ pydatastructs/utils/__init__.py | 2 +- pydatastructs/utils/misc_util.py | 2 +- 5 files changed, 354 insertions(+), 3 deletions(-) create mode 100644 pydatastructs/trees/intervaltree.py create mode 100644 pydatastructs/trees/tests/test_intervaltree.py diff --git a/pydatastructs/trees/__init__.py b/pydatastructs/trees/__init__.py index 6b9df8a22..bbac304fa 100644 --- a/pydatastructs/trees/__init__.py +++ b/pydatastructs/trees/__init__.py @@ -4,7 +4,8 @@ binary_trees, m_ary_trees, space_partitioning_trees, - heaps + heaps, + intervaltree ) from .binary_trees import ( @@ -38,3 +39,9 @@ BinomialHeap ) __all__.extend(heaps.__all__) + +from .intervaltree import ( + Node, + IntervalTree +) +__all__.extend(intervaltree.__all__) diff --git a/pydatastructs/trees/intervaltree.py b/pydatastructs/trees/intervaltree.py new file mode 100644 index 000000000..0f65dc0ad --- /dev/null +++ b/pydatastructs/trees/intervaltree.py @@ -0,0 +1,322 @@ +__all__ = [ + 'Node', + 'IntervalTree' +] + + +class Node(object): + """ + Abstract interval tree node. + + Parameters + ========== + + interval + Required, An interval which is represented + as a pair in tuple (low, high). + + """ + def __init__(self, interval): + self.interval = interval + self.left_child = None + self.right_child = None + self.Max = None + + def hasChild(self): + """ + Checks if Node has child or not. + + Returns + ======= + + True + If the node has a left child or right child or both. + + False + If the node does not has any child. + + """ + if self.left_child or self.right_child: + return True + return False + + def maxOfChild(self): + """ + Returns interval with maximum high value in subtree + rooted with this node + + Returns + ======= + + interval + interval with maximum high value in subtree rooted with this node. + """ + child_interval = list() + if(self.left_child): + child_interval.append(self.left_child.interval) + if(self.right_child): + child_interval.append(self.right_child.interval) + return max(child_interval) + + +class IntervalTree(object): + """ + Abstract binary tree. + + Parameters + ========== + + key + Required, root node of the tree. + + """ + def __init__(self, root): + self.root = root + + def addNode(self, new_node): + """ + Adds a new node to the tree. + + Parameters + ========== + + Node + Required, new node to be added in tree. + + Returns + ======= + + None + + """ + node = self.root + while(node is not None): + if(new_node.interval[0] <= node.interval[0]): + if(node.left_child is None): + node.left_child = new_node + return + node = node.left_child + else: + if(node.right_child is None): + node.right_child = new_node + return + node = node.right_child + + def searchIntervalOverlap(self, query_node): + """ + A utility function to search if any node overlaps with the given Node. + + Parameters + ========== + + query_node + Required, Node to be searched for overlapping. + + Returns + ======= + + Node, Node, boolean + + Node: + parent_node + Parent Node of the child node to be deleted. + None + if given interval node does not overlap with another node. + + Node: + child_node + Child node to be deleted. + None + if given interval node does not overlap with another node. + + boolean: + True + if given interval node overlaps with another node. + False + if given interval node does not overlap with another node + + """ + p_node = None + c_node = self.root + while(c_node): + if(self.isOverlapping(c_node.interval, query_node)): + # print("Overlapping with ", c_node.interval) + return p_node, c_node, True + else: + p_node = c_node + if(c_node.Max >= query_node[0]): + c_node = c_node.left_child + else: + c_node = c_node.right_child + return None, None, False + + def isOverlapping(self, interval_left, interval_right): + """ + A utility function to check if given two nodes + overlaps with each other. + + Parameters + ========== + + interval_left + Required, left node to be searched for overlapping. + + interval_right + Required, right node to be searched for overlapping. + + + Returns + ======= + True + if the two given nodes overlap with each other + + False + if the two given nodes does not overlap with each other + + """ + if((interval_left[0] <= interval_right[1]) and + (interval_right[0] <= interval_left[1])): + return True + + return False + + def maxOfSubtree(self, root_node): + """ + A utility function to set root_node.Max as the maximum + high value in subtree rooted with this node + + Parameters + ========== + + root_node + Root Node of the subtree to be searched for maximum value + + Returns + ======= + + None + """ + if((not root_node.Max) and (root_node.hasChild())): + max_array = [] + if(root_node.left_child): + self.maxOfSubtree(root_node.left_child) + max_array.append(root_node.left_child.Max) + if(root_node.right_child): + self.maxOfSubtree(root_node.right_child) + max_array.append(root_node.right_child.Max) + max_array.append(root_node.interval[1]) + root_node.Max = max(max_array) + return + + else: + root_node.Max = root_node.interval[1] + return + + def constructMax(self): + """ + Sets root.Max as the maximum high value in whole tree. + + """ + node = self.root + self.maxOfSubtree(node) + + def printTree(self): + """ + A utility function to print the Interval Tree + + """ + node_list = [self.root] + it_print = [] + while(len(node_list) != 0): + current_node = node_list[0] + node_list.pop(0) + it_print.append((current_node.interval, current_node.Max)) + # print(current_node.interval, current_node.Max) + if(current_node.left_child is not None): + node_list.append(current_node.left_child) + if(current_node.right_child is not None): + node_list.append(current_node.right_child) + return it_print + + def delete_node(self, node_): + """ + Deletes a given node from the tree + + Parameters + ========== + + Node + Required, node to be deleted from the tree. + + Returns + ======= + + True + if interval node is present in tree and overlaps with another node. + + False + if interval node does not overlap with any node. + + """ + parent_node, node_to_delete, _ = self.searchIntervalOverlap(node_) + + # If no overlap + if not node_to_delete: + return False + + if node_to_delete.hasChild(): + if node_to_delete.left_child: + if self.whichChild(parent_node, node_to_delete) == "left": + parent_node.left_child = node_to_delete.left_child + else: + parent_node.right_child = node_to_delete.left_child + self.reloadTree(node_to_delete.right_child) + else: + if self.whichChild(parent_node, node_to_delete) == "left": + parent_node.left_child = node_to_delete.right_child + else: + parent_node.right_child = node_to_delete.right_child + else: + if parent_node.left_child == node_to_delete: + parent_node.left_child = None + if parent_node.right_child == node_to_delete: + parent_node.right_child = None + return True + + def whichChild(self, p_node, c_node): + """ + A utility function to check whether the given child node is + left child or right child of the given parent node. + + Parameters + ========== + + p_node + Required, parent node. + + c_node + Required, child node. + + Returns + ======= + + "left" + if child node is left child of parent node. + + "right" + if child node is right child of parent node. + + """ + if p_node.left_child == c_node: + return "left" + if p_node.right_child == c_node: + return "right" + + def reloadTree(self, node_): + if node_.hasChild(): + if node_.left_child: + reloadTree(node_.left_child) + if node_.right_child: + reloadTree(node_.left_child) + else: + self.addNode(node_) diff --git a/pydatastructs/trees/tests/test_intervaltree.py b/pydatastructs/trees/tests/test_intervaltree.py new file mode 100644 index 000000000..1a8339314 --- /dev/null +++ b/pydatastructs/trees/tests/test_intervaltree.py @@ -0,0 +1,22 @@ +from pydatastructs.trees.intervaltree import (Node, IntervalTree) + +def test_IntervalTree(): + it = IntervalTree(Node([15, 20])) + it.addNode(Node([10, 30])) + it.addNode(Node([17, 19])) + it.addNode(Node([5, 20])) + it.addNode(Node([12, 15])) + it.addNode(Node([30, 40])) + it.constructMax() + # Explicit check for the printTree() method of IntervalTree Class + assert it.printTree() == [([15, 20], 40), ([10, 30], 30), ([17, 19], 40), ([5, 20], 20), ([12, 15], 15), ([30, 40], 40)] + p_node, c_node, ret = it.searchIntervalOverlap([6, 7]) + assert p_node.interval == [10, 30] + assert c_node.interval == [5, 20] + assert ret is True + p_node, c_node, ret = it.searchIntervalOverlap([-1, -2]) + assert p_node is None + assert c_node is None + assert ret is False + assert it.delete_node([9, 11]) is None + assert it.printTree() == [([15, 20], 40), ([5, 20], 20), ([17, 19], 40), ([12, 15], 15), ([30, 40], 40)] diff --git a/pydatastructs/utils/__init__.py b/pydatastructs/utils/__init__.py index aae87fc5d..fa0dae1f7 100644 --- a/pydatastructs/utils/__init__.py +++ b/pydatastructs/utils/__init__.py @@ -13,6 +13,6 @@ CartesianTreeNode, RedBlackTreeNode, TrieNode, - SkipNode + SkipNode, ) __all__.extend(misc_util.__all__) diff --git a/pydatastructs/utils/misc_util.py b/pydatastructs/utils/misc_util.py index 454dbf3e6..9c58a3d71 100644 --- a/pydatastructs/utils/misc_util.py +++ b/pydatastructs/utils/misc_util.py @@ -10,7 +10,7 @@ 'CartesianTreeNode', 'RedBlackTreeNode', 'TrieNode', - 'SkipNode' + 'SkipNode', ] _check_type = lambda a, t: isinstance(a, t)