heap and priority queue added

Author: nixrajput

src/data_structures/heap/__test__/max_heap.test.py

@@ -110,28 +110,9 @@ def test_find_item_indices_in_heap(self):
         self.assertEqual(maxHeap.find(12), [0])
         self.assertEqual(maxHeap.find(11), [1, 4])
 
-    def test_remove_items_with_heapify_down_from_heap(self):
+    def test_remove_items_from_heap(self):
         """
-        Test to remove items from heap with heapify down
-        """
-        maxHeap = MaxHeap()
-
-        maxHeap.add(3)
-        maxHeap.add(12)
-        maxHeap.add(10)
-        maxHeap.add(11)
-        maxHeap.add(11)
-
-        self.assertEqual(maxHeap.toList(), [12, 11, 10, 3, 11])
-
-        self.assertEqual(maxHeap.remove(12).toList(), [11, 11, 10, 3])
-        self.assertEqual(maxHeap.remove(12).peek(), 11)
-        self.assertEqual(maxHeap.remove(11).toList(), [10, 3])
-        self.assertEqual(maxHeap.remove(10).peek(), 3)
-
-    def test_remove_items_with_heapify_up_from_heap(self):
-        """
-        Test to remove items from heap with heapify up
+        Test to remove items from heap
         """
         maxHeap = MaxHeap()
 
@@ -151,10 +132,11 @@ def test_remove_items_with_heapify_up_from_heap(self):
         self.assertEqual(maxHeap.remove(4).toList(), [10, 8, 6, 7, 6, 1, 5, 3, 2])
         self.assertEqual(maxHeap.remove(3).toList(), [10, 8, 6, 7, 6, 1, 5, 2])
         self.assertEqual(maxHeap.remove(5).toList(), [10, 8, 6, 7, 6, 1, 2])
-        self.assertEqual(maxHeap.remove(10).toList(), [2, 8, 6, 7, 6, 1])
-        self.assertEqual(maxHeap.remove(6).toList(), [2, 8, 1, 7])
-        self.assertEqual(maxHeap.remove(2).toList(), [7, 8, 1])
-        self.assertEqual(maxHeap.remove(1).toList(), [7, 8])
+        self.assertEqual(maxHeap.remove(10).toList(), [8, 7, 6, 2, 6, 1])
+
+        self.assertEqual(maxHeap.remove(6).toList(), [8, 7, 1, 2])
+        self.assertEqual(maxHeap.remove(2).toList(), [8, 7, 1])
+        self.assertEqual(maxHeap.remove(1).toList(), [8, 7])
         self.assertEqual(maxHeap.remove(7).toList(), [8])
         self.assertEqual(maxHeap.remove(8).toList(), [])
 

src/data_structures/heap/__test__/min_heap.test.py

@@ -0,0 +1,168 @@
+import os
+import sys
+import unittest
+
+file_path = os.path.abspath(__file__)
+src_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(file_path))))
+root_folder = os.path.abspath(src_dir)
+sys.path.append(root_folder)
+from data_structures.heap.min_heap import MinHeap
+from utils.comparator import Comparator
+
+
+class TestCase(unittest.TestCase):
+    def test_create_empty_max_heap(self):
+        """
+        Test to create an empty minHeap
+        """
+        minHeap = MinHeap()
+
+        self.assertIsNone(minHeap.peek())
+        self.assertTrue(minHeap.isEmpty())
+
+    def test_add_items_to_heap(self):
+        """
+        Test to add items to the heap and heapify it up
+        """
+        minHeap = MinHeap()
+
+        minHeap.add(5)
+
+        self.assertFalse(minHeap.isEmpty())
+        self.assertEqual(minHeap.peek(), 5)
+        self.assertEqual(minHeap.toList(), [5])
+
+        minHeap.add(3)
+
+        self.assertEqual(minHeap.peek(), 3)
+        self.assertEqual(minHeap.toList(), [3, 5])
+
+        minHeap.add(10)
+
+        self.assertEqual(minHeap.peek(), 3)
+        self.assertEqual(minHeap.toList(), [3, 5, 10])
+
+    def test_poll_items_from_heap(self):
+        """
+        Test to poll items from the heap and heapify it down
+        """
+        minHeap = MinHeap()
+
+        minHeap.add(5)
+        minHeap.add(3)
+        minHeap.add(10)
+        minHeap.add(11)
+        minHeap.add(1)
+
+        self.assertEqual(minHeap.toList(), [1, 3, 10, 11, 5])
+
+        self.assertEqual(minHeap.poll(), 1)
+        self.assertEqual(minHeap.toList(), [3, 5, 10, 11])
+
+        self.assertEqual(minHeap.poll(), 3)
+        self.assertEqual(minHeap.toList(), [5, 11, 10])
+
+        self.assertEqual(minHeap.poll(), 5)
+        self.assertEqual(minHeap.toList(), [10, 11])
+
+        self.assertEqual(minHeap.poll(), 10)
+        self.assertEqual(minHeap.toList(), [11])
+
+        self.assertEqual(minHeap.poll(), 11)
+        self.assertEqual(minHeap.toList(), [])
+
+        self.assertEqual(minHeap.poll(), None)
+        self.assertEqual(minHeap.toList(), [])
+
+    def test_heapify_down_from_right_beanch_in_heap(self):
+        """
+        Test to heapify down through the right branch as well
+        """
+        minHeap = MinHeap()
+
+        minHeap.add(3)
+        minHeap.add(12)
+        minHeap.add(10)
+
+        self.assertEqual(minHeap.toList(), [3, 12, 10])
+
+        minHeap.add(11)
+        self.assertEqual(minHeap.toList(), [3, 11, 10, 12])
+
+        self.assertEqual(minHeap.poll(), 3)
+        self.assertEqual(minHeap.toList(), [10, 11, 12])
+
+    def test_find_item_indices_in_heap(self):
+        """
+        Test to find item indices in heap
+        """
+        minHeap = MinHeap()
+
+        minHeap.add(3)
+        minHeap.add(12)
+        minHeap.add(10)
+        minHeap.add(11)
+        minHeap.add(11)
+
+        self.assertEqual(minHeap.toList(), [3, 11, 10, 12, 11])
+
+        self.assertEqual(minHeap.find(5), [])
+        self.assertEqual(minHeap.find(3), [0])
+        self.assertEqual(minHeap.find(11), [1, 4])
+
+    def test_remove_items_from_heap(self):
+        """
+        Test to remove items from heap
+        """
+        minHeap = MinHeap()
+
+        minHeap.add(3)
+        minHeap.add(10)
+        minHeap.add(5)
+        minHeap.add(6)
+        minHeap.add(7)
+        minHeap.add(4)
+        minHeap.add(6)
+        minHeap.add(8)
+        minHeap.add(2)
+        minHeap.add(1)
+
+        self.assertEqual(minHeap.toList(), [1, 2, 4, 6, 3, 5, 6, 10, 8, 7])
+
+        self.assertEqual(minHeap.remove(8).toList(), [1, 2, 4, 6, 3, 5, 6, 10, 7])
+        self.assertEqual(minHeap.remove(7).toList(), [1, 2, 4, 6, 3, 5, 6, 10])
+        self.assertEqual(minHeap.remove(1).toList(), [2, 3, 4, 6, 10, 5, 6])
+        self.assertEqual(minHeap.remove(2).toList(), [3, 6, 4, 6, 10, 5])
+        self.assertEqual(minHeap.remove(6).toList(), [3, 5, 4, 10])
+        self.assertEqual(minHeap.remove(10).toList(), [3, 5, 4])
+        self.assertEqual(minHeap.remove(5).toList(), [3, 4])
+        self.assertEqual(minHeap.remove(3).toList(), [4])
+        self.assertEqual(minHeap.remove(4).toList(), [])
+
+    def test_remove_items_with_custom_comparator_from_heap(self):
+        """
+        Test to remove items from heap with custom finding comparator
+        """
+        minHeap = MinHeap()
+
+        minHeap.add("a")
+        minHeap.add("bb")
+        minHeap.add("ccc")
+        minHeap.add("dddd")
+
+        self.assertEqual(minHeap.toList(), ["a", "bb", "ccc", "dddd"])
+
+        def customFun(a, b):
+            if len(a) == len(b):
+                return 0
+
+            return -1 if (len(a) < len(b)) else 1
+
+        comparator = Comparator(customFun)
+
+        minHeap.remove("ccc", comparator)
+        self.assertEqual(minHeap.toList(), ["a", "bb", "dddd"])
+
+
+if __name__ == "__main__":
+    unittest.main()

src/data_structures/heap/heap.py

@@ -1,4 +1,3 @@
-import math
 import os
 import sys
 
@@ -21,7 +20,7 @@ def getRightChildIndex(self, parentIndex):
         return (2 * parentIndex) + 2
 
     def getParentIndex(self, childIndex):
-        return math.floor((childIndex - 1) / 2)
+        return (childIndex - 1) // 2
 
     def hasParent(self, childIndex):
         return self.getParentIndex(childIndex) >= 0
@@ -42,10 +41,10 @@ def parent(self, childIndex):
         return self.heapContainer[self.getParentIndex(childIndex)]
 
     def swap(self, indexOne, indexTwo):
-        temp = self.heapContainer[indexTwo]
-
-        self.heapContainer[indexTwo] = self.heapContainer[indexOne]
-        self.heapContainer[indexOne] = temp
+        self.heapContainer[indexOne], self.heapContainer[indexTwo] = (
+            self.heapContainer[indexTwo],
+            self.heapContainer[indexOne],
+        )
 
     def pairIsInCorrectOrder(self, firstElement, secondElement):
         # Checks if pair of heap elements is in correct order.
@@ -73,10 +72,18 @@ def heapifyUp(self, customStartIndex=None):
         # Take the last element (last in array or the bottom left in a tree)
         # in the heap container and lift it up until it is in the correct
         # order with respect to its parent element.
-        currentIndex = customStartIndex or len(self.heapContainer) - 1
+        currentIndex = (
+            customStartIndex
+            if (customStartIndex is not None)
+            else len(self.heapContainer) - 1
+        )
 
-        while self.hasParent(currentIndex) and not self.pairIsInCorrectOrder(
-            self.parent(currentIndex), self.heapContainer[currentIndex]
+        while (
+            self.hasParent(currentIndex)
+            and self.pairIsInCorrectOrder(
+                self.parent(currentIndex), self.heapContainer[currentIndex]
+            )
+            == False
         ):
             self.swap(currentIndex, self.getParentIndex(currentIndex))
             currentIndex = self.getParentIndex(currentIndex)
@@ -151,17 +158,11 @@ def remove(self, item, comparator=None):
 
                 parentItem = self.parent(indexToRemove)
 
-                # If there is no parent or parent is in correct order with the node
-                # we're going to delete then heapify down. Otherwise heapify up.
-                if self.hasLeftChild(indexToRemove) and (
-                    not parentItem
-                    or self.pairIsInCorrectOrder(
-                        parentItem, self.heapContainer[indexToRemove]
-                    )
-                ):
+                # If there is a left child and left child is not
+                # in correct order with the node
+                # we're going to delete then heapify down.
+                if self.hasLeftChild(indexToRemove):
                     self.heapifyDown(indexToRemove)
-                else:
-                    self.heapifyUp(indexToRemove)
 
         return self
 

src/data_structures/priority_queue/__init__.py

@@ -0,0 +1,51 @@
+import os
+import sys
+import unittest
+
+file_path = os.path.abspath(__file__)
+src_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(file_path))))
+root_folder = os.path.abspath(src_dir)
+sys.path.append(root_folder)
+from data_structures.priority_queue.priority_queue import PriorityQueue
+
+
+class TestCase(unittest.TestCase):
+    def test_create_default_priority_queue(self):
+        """
+        Test to create a default PriorityQueue
+        """
+        priorityQueue = PriorityQueue()
+
+        self.assertIsInstance(priorityQueue, PriorityQueue)
+
+    def test_insert_items_to_queue(self):
+        """
+        Test to insert items to the queue and respect priorities
+        """
+        priorityQueue = PriorityQueue()
+
+        priorityQueue.add(10, 1)
+        self.assertEqual(priorityQueue.peek(), 10)
+
+        priorityQueue.add(5, 2)
+        self.assertEqual(priorityQueue.peek(), 10)
+
+        priorityQueue.add(100, 0)
+        self.assertEqual(priorityQueue.peek(), 100)
+
+    def test_objects_in_queue(self):
+        """
+        Test to use objects in priority queue
+        """
+        priorityQueue = PriorityQueue()
+
+        user1 = {"name": "Ram"}
+        user2 = {"name": "Krishna"}
+        user3 = {"name": "Shiva"}
+
+        priorityQueue.add(user1, 1)
+        self.assertEqual(priorityQueue.peek(), user1)
+
+
+if __name__ == "__main__":
+    unittest.main()

src/data_structures/priority_queue/__test__/priority_queue.test.py

@@ -0,0 +1,51 @@
+import os
+import sys
+
+file_path = os.path.abspath(__file__)
+src_dir = os.path.dirname(os.path.dirname(os.path.dirname(file_path)))
+root_folder = os.path.abspath(src_dir)
+sys.path.append(root_folder)
+from utils.comparator import Comparator
+from data_structures.heap.min_heap import MinHeap
+
+
+class PriorityQueue(MinHeap):
+    def __init__(self, comparatorFunction=None):
+        super().__init__(comparatorFunction)
+
+        self.priorities = dict()
+
+        self.compare = Comparator(self.comparePriority)
+
+    def compareValue(self, a, b):
+        if a == b:
+            return 0
+
+        return -1 if a < b else 1
+
+    def comparePriority(self, a, b):
+        if self.priorities.get(a) == self.priorities.get(b):
+            return 0
+
+        return -1 if self.priorities.get(a) < self.priorities.get(b) else 1
+
+    def add(self, item, priority=0):
+        self.priorities[item] = priority
+        super().add(item)
+        return self
+
+    def remove(self, item, comparator=None):
+        super().remove(item, comparator)
+        self.priorities.__delitem__(item)
+        return self
+
+    def changePriority(self, item, priority):
+        self.remove(item, Comparator(self.compareValue))
+        self.add(item, priority)
+        return self
+
+    def findByValue(self, item):
+        return self.find(item, Comparator(self.compareValue))
+
+    def hasValue(self, item):
+        return len(self.findByValue(item)) > 0