#70 max_heap_decrease_key

Author: wojtask

src/solutions/chapter6/section5/exercise4.py

@@ -0,0 +1,26 @@
+from book.chapter6.section2 import max_heapify
+from book.data_structures import KeyObject
+from book.data_structures import PriorityQueue
+from solutions.chapter2.section1.exercise4 import linear_search
+
+
+def max_heap_decrease_key(A: PriorityQueue, x: KeyObject, k: int) -> None:
+    """Increases the value of the element's key to the new value.
+
+    Implements:
+        Max-Heap-Decrease-Key
+
+    Args:
+        A: a max-priority queue implemented by a max-heap containing elements of the dynamic set
+        x: an element in A whose key to decrease
+        k: a new value of the key, at most as large as x.key
+    """
+    if k > x.key:
+        raise ValueError('new key is larger than current key')
+    x.key = k
+    i = __find_index_of_object(A, x)
+    max_heapify(A, i)
+
+
+def __find_index_of_object(A: PriorityQueue, x: KeyObject) -> int:
+    return linear_search(A, A.heap_size, x)

test/test_solutions/test_chapter6.py

@@ -18,6 +18,7 @@
 from solutions.chapter6.section5.exercise3 import min_heap_extract_min
 from solutions.chapter6.section5.exercise3 import min_heap_insert
 from solutions.chapter6.section5.exercise3 import min_heap_minimum
+from solutions.chapter6.section5.exercise4 import max_heap_decrease_key
 from test_case import ClrsTestCase
 from test_util import create_heap
 from util import range_of
@@ -192,3 +193,42 @@ def test_min_heap_insert_overflow(self, data):
             self.assertEqual(A.heap_size, n)
             self.assertArrayPermuted(A, key_objects, end=n)
             self.assertPriorityQueueMappingConsistent(A)
+
+    @given(st.data())
+    def test_max_heap_decrease_key(self, data):
+        keys = data.draw(lists(integers(), min_size=1))
+        key_objects = [KeyObject(key, data.draw(text())) for key in keys]
+        heap = create_heap(key_objects)
+        n = len(key_objects)
+        build_max_heap(heap, n)
+        A = PriorityQueue(heap, n)
+        x = random.choice(key_objects)
+        k = x.key - data.draw(integers(min_value=0))
+
+        max_heap_decrease_key(A, x, k)
+
+        self.assertEqual(x.key, k)
+        self.assertEqual(A.heap_size, n)
+        self.assertMaxHeap(A)
+        self.assertArrayPermuted(A, key_objects, end=n)
+        self.assertPriorityQueueMappingConsistent(A)
+
+    @given(st.data())
+    def test_max_heap_decrease_key_invalid_key(self, data):
+        keys = data.draw(lists(integers(), min_size=1))
+        key_objects = [KeyObject(key, data.draw(text())) for key in keys]
+        heap = create_heap(key_objects)
+        n = len(key_objects)
+        build_max_heap(heap, n)
+        A = PriorityQueue(heap, n)
+        x = random.choice(key_objects)
+        k = x.key + data.draw(integers(min_value=1))
+
+        with self.assertRaisesRegex(ValueError, "new key is larger than current key"):
+            max_heap_decrease_key(A, x, k)
+
+            self.assertNotEquals(x.key, k)
+            self.assertMaxHeap(A)
+            self.assertEqual(A.heap_size, n)
+            self.assertArrayPermuted(A, key_objects, end=n)
+            self.assertPriorityQueueMappingConsistent(A)