rename fields in IntervalPomNode

Author: wojtask

src/chapter14/problem14_1.py

@@ -54,8 +54,8 @@ def _interval_pom_insert_node(T, z):
             y.right = z
     z.left = z.right = T.nil
     z.color = Color.RED
-    z.sum = z.low - z.high
-    z.max = z.low
+    z.overlap = z.low - z.high
+    z.max_overlap = z.low
     z.pom = z.key
     x = y
     while x is not T.nil:
@@ -65,11 +65,11 @@ def _interval_pom_insert_node(T, z):
 
 
 def _update_additional_fields(x):
-    x.sum = x.left.sum + (x.low - x.high) + x.right.sum
-    x.max = max(x.left.max, x.left.sum + x.low, x.left.sum + (x.low - x.high) + x.right.max)
-    if x.max == x.left.max:
+    x.overlap = x.left.overlap + (x.low - x.high) + x.right.overlap
+    x.max_overlap = max(x.left.max_overlap, x.left.overlap + x.low, x.left.overlap + (x.low - x.high) + x.right.max_overlap)
+    if x.max_overlap == x.left.max_overlap:
         x.pom = x.left.pom
-    elif x.max == x.left.sum + x.low:
+    elif x.max_overlap == x.left.overlap + x.low:
         x.pom = x.key
     else:
         x.pom = x.right.pom
@@ -239,8 +239,8 @@ def _copy_all_fields(z, y):
     y.data = z.data
     y.low = z.low
     y.high = z.high
-    y.sum = z.sum
-    y.max = z.max
+    y.overlap = z.overlap
+    y.max_overlap = z.max_overlap
     y.pom = z.pom
     y.color = z.color
     y.left = z.left

src/datastructures/red_black_tree.py

@@ -90,6 +90,6 @@ def __init__(self, key):
         super().__init__(key)
         self.low = 0
         self.high = 0
-        self.sum = 0
-        self.max = -math.inf
+        self.overlap = 0
+        self.max_overlap = -math.inf
         self.pom = None

test/tree_util.py

@@ -19,8 +19,8 @@ def get_binary_search_subtree_inorder_keys(subtree_root, sentinel):
     if subtree_root is sentinel:
         return Array()
     return get_binary_search_subtree_inorder_keys(subtree_root.left, sentinel) \
-        + Array.of(subtree_root.key) \
-        + get_binary_search_subtree_inorder_keys(subtree_root.right, sentinel)
+           + Array.of(subtree_root.key) \
+           + get_binary_search_subtree_inorder_keys(subtree_root.right, sentinel)
 
 
 def get_binary_search_tree_inorder_nodes(tree):
@@ -31,8 +31,8 @@ def get_binary_search_subtree_inorder_nodes(subtree_root, sentinel):
     if subtree_root is sentinel:
         return Array()
     return get_binary_search_subtree_inorder_nodes(subtree_root.left, sentinel) \
-        + Array.of(subtree_root) \
-        + get_binary_search_subtree_inorder_nodes(subtree_root.right, sentinel)
+           + Array.of(subtree_root) \
+           + get_binary_search_subtree_inorder_nodes(subtree_root.right, sentinel)
 
 
 def get_random_binary_search_tree(min_size=1, max_size=20, max_value=999, node_ctor=bt.Node):
@@ -364,16 +364,17 @@ def assert_interval_pom_tree(tree):
 
 
 def assert_interval_pom_subtree(subtree_root, sentinel):
-    assert_that(subtree_root.sum,
-                is_(equal_to(subtree_root.left.sum + (subtree_root.low - subtree_root.high) + subtree_root.right.sum)))
-    assert_that(subtree_root.max, is_(equal_to(max(subtree_root.left.max,
-                                                   subtree_root.left.sum + subtree_root.low,
-                                                   subtree_root.left.sum +
-                                                   (subtree_root.low - subtree_root.high) +
-                                                   subtree_root.right.max))))
-    if subtree_root.max == subtree_root.left.max:
+    assert_that(subtree_root.overlap,
+                is_(equal_to(
+                    subtree_root.left.overlap + (subtree_root.low - subtree_root.high) + subtree_root.right.overlap)))
+    assert_that(subtree_root.max_overlap, is_(equal_to(max(subtree_root.left.max_overlap,
+                                                           subtree_root.left.overlap + subtree_root.low,
+                                                           subtree_root.left.overlap +
+                                                           (subtree_root.low - subtree_root.high) +
+                                                           subtree_root.right.max_overlap))))
+    if subtree_root.max_overlap == subtree_root.left.max_overlap:
         assert_that(subtree_root.pom, is_(equal_to(subtree_root.left.pom)))
-    elif subtree_root.max == subtree_root.left.sum + subtree_root.low:
+    elif subtree_root.max_overlap == subtree_root.left.overlap + subtree_root.low:
         assert_that(subtree_root.pom, is_(equal_to(subtree_root.key)))
     else:
         assert_that(subtree_root.pom, is_(equal_to(subtree_root.right.pom)))