Citlalli Z (Cedar) #4
Conversation
There was a problem hiding this comment.
✨💫 Nice job, Citlalli. I left some comments on your implementation below.
In response to your comprehension questions, while a heap can be implemented using a linked list it's generally not the ideal structure. We prefer arrays since we can easily access parents and children using their index.
🟢
| Time Complexity: O(log n) | ||
| Space Complexity: O(log n) |
There was a problem hiding this comment.
✨ Great. We should note that it's due to the recursive call in heap_up that the space complexity is O(log n). If heap_up were implemented iteratively, this would only require O(1) space complexity since the stack size wouldn't depend on the heap depth.
| """ | ||
| pass | ||
| if value == None: |
There was a problem hiding this comment.
👀 Prefer using is to compare to None
| """ | ||
| pass | ||
| if len(self.store) ==0: |
There was a problem hiding this comment.
👀 We have an empty helper we could use here
| Time Complexity: O(log n) | ||
| Space Complexity: O(log n) |
There was a problem hiding this comment.
✨ Nice. Just as for add, the log space complexity remove is due to the recursive heap_down implementation. We could achieve O(1) space complexity if we used an iterative approach.
| Time complexity: O(1) | ||
| Space complexity: O(1) |
| """ | ||
| pass | ||
| return len(self.store) == 0 |
There was a problem hiding this comment.
Remember that an empty list is falsy
return not self.store| Time complexity: O(log n) | ||
| Space complexity: O(log n) |
There was a problem hiding this comment.
✨ Here's where the O(log n) space complexity in add comes from. Since heap_up calls itself recursively, the worst case for the stack growth will be when the value needs to be moved all the way up the heap, which will have a height of log n. So the space complexity (due to the stack growth) is also O(log n). If we implemented this instead with an iterative approach, the space complexity would be O(1).
| parent = (index -1) // 2 | ||
| if self.store[parent].key > self.store[index].key: | ||
| self.swap(index, parent) | ||
| self.heap_up(parent) | ||
|
|
||
| def heap_down(self, index): |
There was a problem hiding this comment.
✨ Nice approach of first determining the candidate child, then deciding whether the swap is required.
Though not prompted, like heap_up, heap_down is also O(log n) in both time and space complexity. The worst case for re-heapifying is if the new root need to move back down to a leaf, and so the stack growth will be the height of the heap, which is log n. If we implemented this instead with an iterative approach, the space complexity would instead be O(1).
| Time Complexity: O(n logn) | ||
| Space Complexity: O(n) |
There was a problem hiding this comment.
✨ Great. Since sorting using a heap reduces down to building up a heap of n items one-by-one (each taking O(log n)), then pulling them back out again (again taking O(log n) for each of n items), we end up with a time complexity of O(2n log n) → O(n log n). While for the space, we do need to worry about the O(log n) space consume during each add and remove, but they aren't cumulative (each is consumed only during the call to add or remove). However, the internal store for the MinHeap does grow with the size of the input list. So the maximum space would be O(n + log n) → O(n), since n is a larger term than log n.
Note that a fully in-place solution (O(1) space complexity) would require both avoiding the recursive calls, as well as working directly with the originally provided list (no internal store).
| while not heap.empty(): | ||
| list[index] = heap.remove() | ||
| index += 1 |
There was a problem hiding this comment.
Note the since this isn't a fully in-place solution (the MinHeap has a O(n) internal store), we don't necessarily need to modify the passed in list. The tests are written to check the return value, so we could unpack the heap into a new result list to avoid mutating the input.
result = []
while not heap.empty():
result.append(heap.remove())
return result
Heaps Practice
Congratulations! You're submitting your assignment!
Comprehension Questions
heap_up&heap_downmethods useful? Why?