From d92a39cbd0ab3d4d16b548d2048a5c2f9086a423 Mon Sep 17 00:00:00 2001 From: Christabel Sebastian Date: Mon, 26 Apr 2021 19:47:08 -0700 Subject: [PATCH 1/4] implement add() --- lib/min_heap.rb | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/lib/min_heap.rb b/lib/min_heap.rb index 6eaa630..6a76f54 100644 --- a/lib/min_heap.rb +++ b/lib/min_heap.rb @@ -11,14 +11,31 @@ class MinHeap def initialize @store = [] + height = 0 end # This method adds a HeapNode instance to the heap # Time Complexity: ? # Space Complexity: ? def add(key, value = key) - raise NotImplementedError, "Method not implemented yet..." + @store << HeapNode.new(key, value) + + parent_index = @store.length/2 - 1 #parent = (child_element - 1)/2 + is_left_child = @store[2 * parent_index + 1] == @store[-1] #left_child = 2 * parent_index + 1 + #right_child = 2 * parent_index + 2 + if !is_left_child && @store[parent_index].key > key + @store[parent_index], @store[-1] = @store[-1], @store[parent_index] + end + return @store end + # def add(key, value = key) + # @store << HeapNode.new(key, value) + # puts "before: #{@store.map{|pair| pair.key}}" + # if @store[-2] && @store[-2].key[0] > key + # @store[-2], @store[-1] = @store[-1], @store[-2] + # end + # puts "after: #{@store.map{|pair| pair.key}}" + # end # This method removes and returns an element from the heap # maintaining the heap structure From 4868024ff3ea5b9351b167d0fceea09cf5802c5a Mon Sep 17 00:00:00 2001 From: Christabel Sebastian Date: Sat, 1 May 2021 20:29:34 -0700 Subject: [PATCH 2/4] add and remove implemented --- lib/min_heap.rb | 62 ++++++++++++++++++++++++++++++------------------- 1 file changed, 38 insertions(+), 24 deletions(-) diff --git a/lib/min_heap.rb b/lib/min_heap.rb index 6a76f54..5596530 100644 --- a/lib/min_heap.rb +++ b/lib/min_heap.rb @@ -11,40 +11,54 @@ class MinHeap def initialize @store = [] - height = 0 end # This method adds a HeapNode instance to the heap - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O(log n) where n is the number of nodes in the tree + # Space Complexity: O(1) + # parent = (child_element - 1)/2 + # left_child = 2 * parent + 1 + # right_child = 2 * parent + 2 def add(key, value = key) @store << HeapNode.new(key, value) - parent_index = @store.length/2 - 1 #parent = (child_element - 1)/2 - is_left_child = @store[2 * parent_index + 1] == @store[-1] #left_child = 2 * parent_index + 1 - #right_child = 2 * parent_index + 2 - if !is_left_child && @store[parent_index].key > key - @store[parent_index], @store[-1] = @store[-1], @store[parent_index] + current = @store.length - 1 + parent = (current - 1) / 2 + while @store[current].key < @store[parent].key do + @store[parent], @store[current] = @store[current], @store[parent] + current = parent + parent = current / 2 end + return @store end - # def add(key, value = key) - # @store << HeapNode.new(key, value) - # puts "before: #{@store.map{|pair| pair.key}}" - # if @store[-2] && @store[-2].key[0] > key - # @store[-2], @store[-1] = @store[-1], @store[-2] - # end - # puts "after: #{@store.map{|pair| pair.key}}" - # end # This method removes and returns an element from the heap # maintaining the heap structure - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O(log n) where n is the number of nodes in the tree + # Space Complexity: O(1) def remove() - raise NotImplementedError, "Method not implemented yet..." - end + @store[0], @store[-1] = @store[-1], @store[0] + removed_node = @store.pop + + current = 0 + left_child = current * 2 + 1 + right_child = current * 2 + 2 + child = @store[left_child].key < @store[right_child].key ? left_child : right_child + + while @store[current].key > @store[child].key do + @store[child], @store[current] = @store[current], @store[child] + + current = child + left_child = current * 2 + 1 + right_child = current * 2 + 2 + if @store[left_child] && @store[right_child] + child = @store[left_child].key < @store[right_child].key ? left_child : right_child + end + end + return removed_node.value + end # Used for Testing def to_s @@ -56,7 +70,7 @@ def to_s end output += @store.last.value + "]" - + return output end @@ -75,10 +89,10 @@ def empty? # Time complexity: ? # Space complexity: ? def heap_up(index) - + end - # This helper method takes an index and + # 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) @@ -91,4 +105,4 @@ def swap(index_1, index_2) @store[index_1] = @store[index_2] @store[index_2] = temp end -end \ No newline at end of file +end From 961b204d0b34f3d9d82d89194d5f08cfbf3c4ddb Mon Sep 17 00:00:00 2001 From: Christabel Sebastian Date: Sat, 1 May 2021 20:44:24 -0700 Subject: [PATCH 3/4] heap_up and heap_down helpers implemented --- lib/min_heap.rb | 83 ++++++++++++++++++++++--------------------------- 1 file changed, 38 insertions(+), 45 deletions(-) diff --git a/lib/min_heap.rb b/lib/min_heap.rb index 5596530..58192f1 100644 --- a/lib/min_heap.rb +++ b/lib/min_heap.rb @@ -14,49 +14,23 @@ def initialize end # This method adds a HeapNode instance to the heap - # Time Complexity: O(log n) where n is the number of nodes in the tree - # Space Complexity: O(1) - # parent = (child_element - 1)/2 - # left_child = 2 * parent + 1 - # right_child = 2 * parent + 2 + # Time Complexity: O(log n) where n is the number of nodes in the heap + # Space Complexity: O(2) == O(1) def add(key, value = key) @store << HeapNode.new(key, value) - - current = @store.length - 1 - parent = (current - 1) / 2 - while @store[current].key < @store[parent].key do - @store[parent], @store[current] = @store[current], @store[parent] - current = parent - parent = current / 2 - end - + heap_up(@store.length - 1) return @store end # This method removes and returns an element from the heap # maintaining the heap structure - # Time Complexity: O(log n) where n is the number of nodes in the tree - # Space Complexity: O(1) + # Time Complexity: O(log n) where n is the number of nodes in the heap + # Space Complexity: O(2) == O(1) def remove() + return nil if empty? @store[0], @store[-1] = @store[-1], @store[0] removed_node = @store.pop - - current = 0 - left_child = current * 2 + 1 - right_child = current * 2 + 2 - child = @store[left_child].key < @store[right_child].key ? left_child : right_child - - while @store[current].key > @store[child].key do - @store[child], @store[current] = @store[current], @store[child] - - current = child - left_child = current * 2 + 1 - right_child = current * 2 + 2 - if @store[left_child] && @store[right_child] - child = @store[left_child].key < @store[right_child].key ? left_child : right_child - end - end - + heap_down(0) return removed_node.value end @@ -75,28 +49,47 @@ def to_s end # This method returns true if the heap is empty - # Time complexity: ? - # Space complexity: ? + # Time complexity: O(1) ? I think the length of arrays is somehow cached or something in Ruby? If not, then O(n) where n is the number of elements in the array + # Space complexity: O(1) def empty? - raise NotImplementedError, "Method not implemented yet..." + 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. + # moves it up the heap, if it is less than its parent node. # It could be **very** helpful for the add method. - # Time complexity: ? - # Space complexity: ? - def heap_up(index) - + # Time complexity: O(log n) where n is the number of nodes in the heap + # Space complexity: O(1) + def heap_up(current) + parent = (current - 1) / 2 + while @store[current].key < @store[parent].key do + @store[parent], @store[current] = @store[current], @store[parent] + current = parent + parent = current / 2 + end 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) - raise NotImplementedError, "Method not implemented yet..." + # moves it down the heap if it's larger + # than its child nodes. + def heap_down(current) + current = 0 + left_child = current * 2 + 1 + right_child = current * 2 + 2 + child = @store[left_child].key < @store[right_child].key ? left_child : right_child + + while @store[current].key > @store[child].key do + @store[child], @store[current] = @store[current], @store[child] + + current = child + left_child = current * 2 + 1 + right_child = current * 2 + 2 + if @store[left_child] && @store[right_child] + child = @store[left_child].key < @store[right_child].key ? left_child : right_child + end + end end # If you want a swap method... you're welcome From 1d5a36d47cb8846bb38e44331d0541a644eb0ef7 Mon Sep 17 00:00:00 2001 From: Christabel Sebastian Date: Sat, 1 May 2021 21:18:56 -0700 Subject: [PATCH 4/4] heap_sort implemented --- lib/heap_sort.rb | 18 ++++++++++++++---- test/heapsort_test.rb | 8 ++++---- 2 files changed, 18 insertions(+), 8 deletions(-) diff --git a/lib/heap_sort.rb b/lib/heap_sort.rb index c8a32a4..93daaad 100644 --- a/lib/heap_sort.rb +++ b/lib/heap_sort.rb @@ -1,8 +1,18 @@ - +require_relative 'min_heap' # This method uses a heap to sort an array. -# Time Complexity: ? -# Space Complexity: ? +# Time Complexity: O(n log n) where n is the number of elements in the given array +# Space Complexity: O(n) def heap_sort(list) - raise NotImplementedError, "Method not implemented yet..." + heap = [] + list.each_with_index do |element, current| + heap << element + parent = current / 2 + while heap[current] < heap[parent] do + heap[parent], heap[current] = heap[current], heap[parent] + current = parent + parent = current / 2 + end + end + return heap end \ No newline at end of file diff --git a/test/heapsort_test.rb b/test/heapsort_test.rb index 34402ac..76e3fdc 100644 --- a/test/heapsort_test.rb +++ b/test/heapsort_test.rb @@ -1,12 +1,12 @@ require_relative "test_helper" -xdescribe "heapsort" do +describe "heap_sort" do it "sorts an empty array" do # Arrange list = [] # Act - result = heapsort(list) + result = heap_sort(list) # Assert expect(result).must_equal [] @@ -17,7 +17,7 @@ list = [5] # Act - result = heapsort(list) + result = heap_sort(list) # Assert expect(result).must_equal [5] @@ -28,7 +28,7 @@ list = [5, 27, 3, 16, -50] # Act - result = heapsort(list) + result = heap_sort(list) # Assert expect(result).must_equal [-50, 3, 5, 16, 27]