Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Leaves - Mariya #30

Open
wants to merge 1 commit into
base: master
Choose a base branch
from
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
23 changes: 19 additions & 4 deletions lib/heap_sort.rb
Original file line number Diff line number Diff line change
@@ -1,8 +1,23 @@


require_relative 'min_heap'
# This method uses a heap to sort an array.
# Time Complexity: ?
# Space Complexity: ?
# Time Complexity: O (n log (n))
# Space Complexity: O(n)
def heap_sort(list)
Comment on lines +4 to 6

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

👍

raise NotImplementedError, "Method not implemented yet..."
return [] if list.nil?
return list if list.length == 1

heap = MinHeap.new

list.each do |node|
heap.add(node)
end

sorted_heap = []

list.length.times do
node = heap.remove
sorted_heap << node
end
return sorted_heap
end
94 changes: 68 additions & 26 deletions lib/min_heap.rb
Original file line number Diff line number Diff line change
@@ -1,73 +1,115 @@
class HeapNode
attr_reader :key, :value

def initialize(key, value)
@key = key
@value = value
end
end

class MinHeap

def initialize
@store = []
end

# This method adds a HeapNode instance to the heap
# Time Complexity: ?
# Space Complexity: ?
# Time Complexity: O(log(n))
# Space Complexity: O(1)
def add(key, value = key)
Comment on lines +17 to 19

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Since heap_up is recursive the space complexity is O(log n)

raise NotImplementedError, "Method not implemented yet..."
newNode = HeapNode.new(key, value)
@store << newNode

heap_up(@store.length - 1)
end

# This method removes and returns an element from the heap
# maintaining the heap structure
# Time Complexity: ?
# Space Complexity: ?
# Time Complexity: O(log(n))
# Space Complexity: O(1)
def remove()
Comment on lines +28 to 30

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

👍 However like add the space complexity is O(log n)

raise NotImplementedError, "Method not implemented yet..."
return nil if @store.empty?

length = @store.length
swap(0, length -1)

removed_node = @store.pop
heap_down(0)

return removed_node.value
end


# Used for Testing
def to_s
return "[]" if @store.empty?

output = "["
(@store.length - 1).times do |index|
output += @store[index].value + ", "
end

output += @store.last.value + "]"

return output
end

# This method returns true if the heap is empty
# Time complexity: ?
# Space complexity: ?
# Time complexity: O(1)
# Space complexity: O(1)
def empty?
Comment on lines +58 to 60

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

👍

raise NotImplementedError, "Method not implemented yet..."
if @store.length == 0
return true
else
return false
end
Comment on lines +61 to +65

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Suggested change
if @store.length == 0
return true
else
return false
end
return @store.length == 0

end

private

# This helper method takes an index and
# moves it up the heap, if it is less than it's parent node.
# It could be **very** helpful for the add method.
# Time complexity: ?
# Space complexity: ?
# Time complexity: O(log (n))
# Space complexity: O(1)
def heap_up(index)
Comment on lines +73 to 75

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Since this is a recursive method, it's going to be O(log n) space complexity.

parent = (index - 1) / 2

if @store[parent].key > @store[index].key
swap(parent, index)
end

while parent > 0
return heap_up(parent)
end
Comment on lines +82 to +84

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Note you're making extra recursive calls here. You only want to heap_up if you made a swap, and since you're returning here you don't need a while loop.

end

# This helper method takes an index and
# moves it up the heap if it's smaller
# than it's parent node.
def heap_down(index)

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This works, but it has issues with extra swaps.

raise NotImplementedError, "Method not implemented yet..."
left_child = (index * 2) + 1
right_child = (index * 2) + 2

return if @store[left_child].nil? && @store[right_child].nil?

if @store[left_child].nil?
smallest_child = right_child
elsif @store[right_child].nil?
smallest_child = left_child
elsif @store[left_child].key < @store[right_child].key
smallest_child = left_child
else
smallest_child = right_child
end

if @store[index].key > @store[smallest_child].key
swap(index, smallest_child)
end

return heap_down(smallest_child)

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Similar to the heap_up method you're making extra recursive calls. You only need to continue to heap_down if you make a swap.

end

# If you want a swap method... you're welcome
def swap(index_1, index_2)
temp = @store[index_1]
Expand Down