Tweaks to autoresizelist, added build_heap, but it has a bug (as is being caught by the unit test).

Author: calebmadrigal

autoresizelist.py

@@ -19,8 +19,8 @@ def __setitem__(self, key, value):
         self._data[key] = value
 
     def __getitem__(self, key):
-        if key >= len(self._data):
-            self._data += [self.fill] * (key - len(self._data) + 1)
+        #if key >= len(self._data):
+        #    self._data += [self.fill] * (key - len(self._data) + 1)
         return self._data[key]
 
     def __delitem__(self, key):
@@ -35,6 +35,12 @@ def __eq__(self, other):
     def __len__(self):
         return len(self._data)
 
+    def append(self, item):
+        self._data.append(item)
+
+    def prepend(self, item):
+        self._data = [item] + self._data
+
 if __name__ == "__main__":
     import unittest
     testsuite = unittest.TestLoader().discover('test', pattern="*autoresizelist*")

heap.py

@@ -15,19 +15,17 @@ class HeapType(Enum):
 
 class Heap:
     def __init__(self, initial_data=None, heap_type=HeapType.maxheap):
-        if initial_data is None:
-            self.data = AutoResizeList()
-        else:
-            self.data = AutoResizeList(initial_data)
-            self.build_heap(initial_data)
-
         self.heap_type = heap_type
         if heap_type == HeapType.maxheap:
             self.comparator = lambda x, y: x > y
         else:
             self.comparator = lambda x, y: x < y
 
-        self.size = len(self.data)
+        self.data = AutoResizeList()
+        if initial_data is not None:
+            self.build_heap(initial_data)
+
+        self._size = len(self.data)
 
     def _left_child(self, index):
         return 2*index + 1
@@ -46,7 +44,8 @@ def _swap(self, i1, i2):
 
     def build_heap(self, initial_data):
         for i in initial_data:
-            self.data.append(i)
+            self.data.prepend(i)
+            self.heap_down(0)
 
     def heap_up(self, index):
         # If we are at the root, return - we are done
@@ -63,8 +62,14 @@ def heap_up(self, index):
     def heap_down(self, index):
         left_index = self._left_child(index)
         right_index = self._right_child(index)
-        left = self.data[left_index]
-        right = self.data[right_index]
+        try:
+            left = self.data[left_index]
+        except IndexError:
+            left = None
+        try:
+            right = self.data[right_index]
+        except IndexError:
+            right = None
 
         # Find the largest child
         largest_child = left
@@ -84,8 +89,8 @@ def heap_down(self, index):
             self.heap_down(largest_child_index)
 
     def push(self, item):
-        insert_index = self.size  # Insert at the end
-        self.size += 1
+        insert_index = self._size  # Insert at the end
+        self._size += 1
 
         self.data[insert_index] = item
         self.heap_up(insert_index)
@@ -103,19 +108,21 @@ def pop(self):
         item = self.data[0]
 
         # Move the bottom-most, right-most item to the root
-        self.data[0] = self.data[self.size-1]
-        self.data[self.size-1] = None
-        self.size -= 1
+        self.data[0] = self.data[self._size-1]
+        self.data[self._size-1] = None
+        self._size -= 1
 
         self.heap_down(0)
 
         return item
 
+    def size(self):
+        return self._size
+
     def __repr__(self):
         return str(self.data)
 
 if __name__ == "__main__":
     import unittest
     testsuite = unittest.TestLoader().discover('test', pattern="*heap*")
     unittest.TextTestRunner(verbosity=1).run(testsuite)
-

test/test_autoresizelist.py

@@ -19,7 +19,9 @@ def testSet(self):
 
     def testGet(self):
         c = AutoResizeList([], fill=100)
-        self.assertEqual(c[10], 100)
+        c[10] = 1
+        self.assertEqual(c[10], 1)
+        self.assertEqual(c[9], 100)
 
     def testDel(self):
         d = AutoResizeList([0, 1, 2])
@@ -28,14 +30,19 @@ def testDel(self):
         self.assertEqual(d._data, [0, 1, 2, 4])
 
     def testEqual(self):
-        a = AutoResizeList([1,2,3])
-        b = AutoResizeList([1,2,3])
+        a = AutoResizeList([1, 2, 3])
+        b = AutoResizeList([1, 2, 3])
         self.assertEqual(a, b)
 
     def testLen(self):
-        a = AutoResizeList([1,2,3])
+        a = AutoResizeList([1, 2, 3])
         self.assertEqual(len(a), 3)
 
+    def testPrepend(self):
+        a = AutoResizeList([1, 2, 3])
+        a.prepend(0)
+        self.assertEqual(0, a._data[0])
+
 if __name__ == '__main__':
     unittest.main()
 

test/test_heap.py

@@ -1,13 +1,20 @@
 import unittest
 import sys
 import os.path
+import random
 
 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), os.path.pardir)))
 import heap
 
 
-class HeapTest(unittest.TestCase):
+def is_heap(h):
+    sorted_data = list(sorted(filter(lambda x: x is not None, h.data), reverse=True))
+    pop_order = [h.pop() for _ in range(h.size())]
+    print("\nsorted data: {0}\npop_order:   {1}".format(sorted_data, pop_order))
+    return sorted_data == pop_order
+
 
+class HeapTest(unittest.TestCase):
     def testMaxHeapPushPop(self):
         # Test push
         h = heap.Heap()
@@ -35,6 +42,14 @@ def testMaxHeapPushPop(self):
         self.assertEqual(h.pop(), 9)
         self.assertEqual(h.pop(), 7)
 
+        # Larger test
+        data = [93, 89, 91, 84, 87, 54, 71, 62, 75, 35, 43, 50, 77, 27, 14, 42, 13, 35, 10, 4]
+        h2 = heap.Heap()
+        for d in data:
+            h2.push(d)
+
+        self.assertTrue(is_heap(h2))
+
     def testMinHeapPushPop(self):
         # Test Push
         h = heap.Heap([], heap.HeapType.minheap)
@@ -65,14 +80,14 @@ def testMinHeapPushPop(self):
         self.assertEqual(h.pop(), -10)
 
     def testMaxHeapBuild(self):
-        pass
-        #data = [6, 1, 4, 9, 8, 2, 3]
-        #h = heap.Heap(data, heap.HeapType.maxheap)
-        #self.assertEqual(h.pop(), 9)
-        #self.assertEqual(h.pop(), 8)
-        #h.push(15)
-        #h.push(0)
-        #self.assertEqual(h.pop(), 15)
+        data = [98, 45, 69, 85, 34, 66, 10, 2, 11, 3, 21, 30, 91, 32, 55, 74, 93, 17, 67, 19]
+        h = heap.Heap(data)
+        self.assertTrue(is_heap(h))
+
+        # data2 = [random.randint(1, 100) for _ in range(20)]
+        # print("\n\ndata:        {0}".format(data2))
+        # h3 = heap.Heap(data2[:])
+        # self.assertTrue(is_heap(h3))
 
 if __name__ == '__main__':
     unittest.main()