Heaps uses DynamicOneDimensionalArray

Author: prshnt19

pydatastructs/linear_data_structures/arrays.py

@@ -255,6 +255,9 @@ def delete(self, idx):
     def size(self):
         return self._size
 
+    def __len__(self):
+        return self._size
+
 class ArrayForTrees(DynamicOneDimensionalArray):
     """
     Utility dynamic array for storing nodes of a tree.

pydatastructs/trees/heaps.py

@@ -82,15 +82,16 @@ def __new__(cls, elements=None, heap_property="min", d=4):
         else:
             raise ValueError("%s is invalid heap property"%(heap_property))
         if elements is None:
-            elements = []
+            elements = DynamicOneDimensionalArray(TreeNode, 0)
+            # elements = []
         obj.heap = elements
-        obj._last_pos_filled = len(elements) - 1
+        obj._last_pos_filled = obj.heap._last_pos_filled
         obj._build()
         return obj
 
     def _build(self):
         for i in range(self._last_pos_filled + 1):
-            self.heap[i].left, self.heap[i].right = \
+            self.heap[i]._leftmost, self.heap[i]._rightmost = \
                 self.d*i + 1, self.d*i + self.d
         for i in range((self._last_pos_filled + 1)//self.d, -1, -1):
             self._heapify(i)
@@ -143,7 +144,7 @@ def insert(self, key, data):
         self.heap.append(new_node)
         self._last_pos_filled += 1
         i = self._last_pos_filled
-        self.heap[i].left, self.heap[i].right = self.d*i + 1, self.d*i + self.d
+        self.heap[i]._leftmost, self.heap[i]._rightmost = self.d*i + 1, self.d*i + self.d
 
         while True:
             parent = (i - 1)//self.d
@@ -171,22 +172,23 @@ def extract(self):
         else:
             element_to_be_extracted = TreeNode(self.heap[0].key, self.heap[0].data)
             self._swap(0, self._last_pos_filled)
-            self.heap[self._last_pos_filled] = TreeNode(float('inf') if self.heap_property == 'min'
-                                                                else float('-inf'), None)
-            self._heapify(0)
-            self.heap.pop()
+            # self.heap[self._last_pos_filled] = TreeNode(float('inf') if self.heap_property == 'min'
+            #                                                     else float('-inf'), None)
+            self.heap.delete(self._last_pos_filled)
             self._last_pos_filled -= 1
+            self._heapify(0)
+            # self.heap.pop
             return element_to_be_extracted
 
     def __str__(self):
         to_be_printed = ['' for i in range(self._last_pos_filled + 1)]
         for i in range(self._last_pos_filled + 1):
             node = self.heap[i]
-            if node.left <= self._last_pos_filled:
-                if node.right <= self._last_pos_filled:
-                    children = [x for x in range(node.left, node.right + 1)]
+            if node._leftmost <= self._last_pos_filled:
+                if node._rightmost <= self._last_pos_filled:
+                    children = [x for x in range(node._leftmost, node._rightmost + 1)]
                 else:
-                    children = [x for x in range(node.left, self._last_pos_filled + 1)]
+                    children = [x for x in range(node._leftmost, self._last_pos_filled + 1)]
             else:
                 children = []
             to_be_printed[i] = (node.key, node.data, children)
@@ -303,6 +305,7 @@ class TernaryHeap(DHeap):
     ==========
 
     .. [1] https://en.wikipedia.org/wiki/D-ary_heap
+    .. [2] https://ece.uwaterloo.ca/~dwharder/aads/Algorithms/d-ary_heaps/Ternary_heaps/
     """
     def __new__(cls, elements=None, heap_property="min"):
         obj = DHeap.__new__(cls, elements, heap_property, 3)

pydatastructs/trees/tests/test_heaps.py

@@ -1,4 +1,5 @@
 from pydatastructs.trees.heaps import BinaryHeap, TernaryHeap, BinomialHeap, DHeap
+from pydatastructs.linear_data_structures.arrays import DynamicOneDimensionalArray
 from pydatastructs.miscellaneous_data_structures.binomial_trees import BinomialTree
 from pydatastructs.utils.misc_util import TreeNode, BinomialTreeNode
 from pydatastructs.utils.raises_util import raises
@@ -25,10 +26,11 @@ def test_BinaryHeap():
         "(3, 3, []), (25, 25, []), (1, 1, []), "
         "(2, 2, []), (7, 7, [])]")
 
-    expected_extracted_element = max_heap.heap[0].key
-    assert max_heap.extract().key == expected_extracted_element
+    assert max_heap.extract().key == 100
 
     expected_sorted_elements = [36, 25, 19, 17, 7, 3, 2, 1]
+    l=max_heap.heap[0].left
+    l=max_heap.heap[0].right
     sorted_elements = []
     for _ in range(8):
         sorted_elements.append(max_heap.extract().key)
@@ -39,7 +41,7 @@ def test_BinaryHeap():
                 TreeNode(1, 1), TreeNode(2, 2), TreeNode(3, 3),
                 TreeNode(17, 17), TreeNode(19, 19), TreeNode(36, 36)
             ]
-    min_heap = BinaryHeap(elements = elements, heap_property="min")
+    min_heap = BinaryHeap(elements=DynamicOneDimensionalArray(TreeNode, 9, elements), heap_property="min")
     assert min_heap.extract().key == 1
 
     expected_sorted_elements = [2, 3, 7, 17, 19, 25, 36, 100]
@@ -77,7 +79,7 @@ def test_TernaryHeap():
         TreeNode(1, 1), TreeNode(2, 2), TreeNode(3, 3),
         TreeNode(17, 17), TreeNode(19, 19), TreeNode(36, 36)
     ]
-    min_heap = TernaryHeap(elements=elements, heap_property="min")
+    min_heap = TernaryHeap(elements=DynamicOneDimensionalArray(TreeNode, 9, elements), heap_property="min")
     expected_extracted_element = min_heap.heap[0].key
     assert min_heap.extract().key == expected_extracted_element
 
@@ -104,8 +106,7 @@ def test_DHeap():
            '(36, 36, []), (17, 17, []), (3, 3, []), (19, 19, []), '
            '(1, 1, []), (2, 2, []), (7, 7, [])]')
 
-    expected_extracted_element = max_heap.heap[0].key
-    assert max_heap.extract().key == expected_extracted_element
+    assert max_heap.extract().key == 100
 
     expected_sorted_elements = [36, 25, 19, 17, 7, 3, 2, 1]
     sorted_elements = []
@@ -118,7 +119,7 @@ def test_DHeap():
         TreeNode(1, 1), TreeNode(2, 2), TreeNode(3, 3),
         TreeNode(17, 17), TreeNode(19, 19), TreeNode(36, 36)
     ]
-    min_heap = DHeap(elements=elements, heap_property="min")
+    min_heap = DHeap(elements=DynamicOneDimensionalArray(TreeNode, 9, elements), heap_property="min")
     assert min_heap.extract().key == 1
 
     expected_sorted_elements = [2, 3, 7, 17, 19, 25, 36, 100]