Water - Mackenzie #24
Conversation
…error was, reversed less than and greater than signs
| # Time Complexity: O(m+n) | ||
| # Space Complexity: O(n) - will have a call stack equal to number of nodes, though we are make a constant number of data structures... maybe O(1) | ||
| def heap_sort(list) |
There was a problem hiding this comment.
👍 The time complexity will be O(n log n) because you are adding n elements to the heap and each addition will take Log n time.
Then you remove n elements (each taking log n time).
| # Time Complexity: O(m+1), where m is height - O(1) for adding, O(m) for heap up | ||
| # Space Complexity: O(1) - no new data structures made, but O(m) for heap up call stack (is it the number of calls in the calls stack or number of structures made?) | ||
| def add(key, value = key) |
There was a problem hiding this comment.
👍 , However the time complexity is O(log n) because heap_up will go level-by-level in the tree. Since the tree is always balanced, m = log n.
| # Time Complexity: O(n+1) | ||
| # Space Complexity: O(1) | ||
| def remove() |
There was a problem hiding this comment.
👍 However the time complexity will be O(log n) time (because of the recursive swaps) and space complexity of O(log n) as well due to the call stack.
| def heap_up(index) | ||
| return if index == 0 | ||
|
|
||
| if @store[index].key < @store[((index - (index % 3)) / 2)].key |
There was a problem hiding this comment.
It might be easier just to do
parent_index = (index - 1) / 2And use that variable
| # Time complexity: O(m) where m is height | ||
| # Space complexity: O(1), no persistent data structure is made beyond 1 temporary reassigned variable | ||
| def heap_up(index) |
There was a problem hiding this comment.
👍 , but I would give O(log n) for the time complexity because the tree is always balanced and the height is always log n. The space complexity would be O(log n) due to the call stack (recursion).
| if !@store[index * 2 + 1].nil? && @store[index].key > @store[index * 2 + 1].key | ||
| swap(index, (index * 2 + 1)) | ||
| end | ||
|
|
||
| if !@store[index * 2 + 2].nil? && @store[index].key > @store[index * 2 + 2].key | ||
| swap(index, (index * 2 + 2)) | ||
| end | ||
|
|
||
| heap_down(index * 2 + 1) | ||
| heap_down(index * 2 + 2) |
There was a problem hiding this comment.
You're doing a bunch of extra swaps here. Instead find the smallest child and then if it's smaller than the parent, swap those and continue. You should never need to swap both the right and left children, as well as heap down both children.
| end | ||
|
|
||
| # If you want a swap method... you're welcome | ||
| #THANK YOUUUUUU |
Heaps Practice
Congratulations! You're submitting your assignment!
Comprehension Questions
heap_up&heap_downmethods useful? Why?