From de8ebe45c598b2c642a9c4fb0f0078bd456dcd1a Mon Sep 17 00:00:00 2001 From: Cyndi Lopez Date: Mon, 30 Sep 2019 20:18:04 -0700 Subject: [PATCH 1/2] . --- lib/heap_sort.rb | 42 +++++++++++++++++++++--- lib/min_heap.rb | 76 +++++++++++++++++++++++++++++++------------ test/heapsort_test.rb | 14 ++++---- 3 files changed, 100 insertions(+), 32 deletions(-) diff --git a/lib/heap_sort.rb b/lib/heap_sort.rb index c8a32a4..17fba66 100644 --- a/lib/heap_sort.rb +++ b/lib/heap_sort.rb @@ -1,8 +1,40 @@ # This method uses a heap to sort an array. -# Time Complexity: ? -# Space Complexity: ? -def heap_sort(list) - raise NotImplementedError, "Method not implemented yet..." -end \ No newline at end of file +# Time Complexity: O(n logn) +# Space Complexity: O(1) +def heapsort(list) + n = list.length + (n / 2).downto(0) do |i| + heapify(list, i, n) + end + n -= 1 + while n > 0 + list[0], list[n] = list[n], list[0] + n -= 1 + heapify(list, 0, n) + end + return list +end + +def heapify(array, index, len) + greatest = index + left_child = 2 * index + 1 + right_child = 2 * index + 2 + if left_child < len && array[left_child] > array[index] + greatest = left_child + end + if right_child < len && array[right_child] > array[greatest] + greatest = right_child + end + if greatest != index + swap(array, greatest, index) + heapify(array, greatest, len) + end +end + +def swap(array, index_1, index_2) + temp = array[index_1] + array[index_1] = array[index_2] + array[index_2] = temp +end diff --git a/lib/min_heap.rb b/lib/min_heap.rb index 6eaa630..12a8d75 100644 --- a/lib/min_heap.rb +++ b/lib/min_heap.rb @@ -8,27 +8,30 @@ def initialize(key, value) 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(n) def add(key, value = key) - raise NotImplementedError, "Method not implemented yet..." + new_heap_node = HeapNode.new(key, value) + @store.append(new_heap_node) + 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() - raise NotImplementedError, "Method not implemented yet..." + swap(0, @store.length - 1) + result = @store.pop + heap_down(0) unless @store.empty? + return result.value end - # Used for Testing def to_s return "[]" if @store.empty? @@ -39,15 +42,15 @@ def to_s end output += @store.last.value + "]" - + return output end # This method returns true if the heap is empty - # Time complexity: ? - # Space complexity: ? + # Time complexity: O(n) + # Space complexity: O(1) def empty? - raise NotImplementedError, "Method not implemented yet..." + return true if @store == [] end private @@ -55,17 +58,50 @@ def empty? # 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) - + parent_index = find_parent_index(index) + while @store[index].key < @store[parent_index].key && parent_index >= 0 + swap(parent_index, index) + index = parent_index + parent_index = find_parent_index(index) + end + end + + def find_parent_index(child_index) + if child_index % 2 == 0 + parent_index = (child_index - 2) / 2 + else + parent_index = (child_index - 1) / 2 + end + return parent_index end - # This helper method takes an index and - # moves it up the heap if it's smaller - # than it's parent node. + # This helper method takes an index and + # moves it down the heap if it's bigger + # than it's child's node. + # Time complexity: O(log n) + # Space complexity: O(1) def heap_down(index) - raise NotImplementedError, "Method not implemented yet..." + child_index = find_minimum_child_index(index) + while child_index <= @store.length - 1 && @store[index].key > @store[child_index].key + swap(index, child_index) + index = child_index + child_index = find_minimum_child_index(index) + end + end + + def find_minimum_child_index(index) + child_index1 = 2 * index + 1 + child_index2 = 2 * index + 2 + return child_index1 if child_index1 > @store.length - 1 + if @store[child_index1].key <= @store[child_index2].key + min_child_index = child_index1 + else + min_child_index = child_index2 + end + return min_child_index end # If you want a swap method... you're welcome @@ -74,4 +110,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 diff --git a/test/heapsort_test.rb b/test/heapsort_test.rb index 34402ac..9964e33 100644 --- a/test/heapsort_test.rb +++ b/test/heapsort_test.rb @@ -1,8 +1,8 @@ require_relative "test_helper" -xdescribe "heapsort" do +describe "heapsort" do it "sorts an empty array" do - # Arrange + # Arrange list = [] # Act @@ -13,7 +13,7 @@ end it "can sort a 1-element array" do - # Arrange + # Arrange list = [5] # Act @@ -22,9 +22,9 @@ # Assert expect(result).must_equal [5] end - + it "can sort a 5-element array" do - # Arrange + # Arrange list = [5, 27, 3, 16, -50] # Act @@ -32,5 +32,5 @@ # Assert expect(result).must_equal [-50, 3, 5, 16, 27] - end -end \ No newline at end of file + end +end From 848d50855a57d29eb863d790de1c844553f5ae96 Mon Sep 17 00:00:00 2001 From: Cyndi Lopez Date: Mon, 30 Sep 2019 20:44:46 -0700 Subject: [PATCH 2/2] swap function used --- lib/heap_sort.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/heap_sort.rb b/lib/heap_sort.rb index 17fba66..c68584c 100644 --- a/lib/heap_sort.rb +++ b/lib/heap_sort.rb @@ -10,7 +10,7 @@ def heapsort(list) end n -= 1 while n > 0 - list[0], list[n] = list[n], list[0] + swap(list, 0, n) n -= 1 heapify(list, 0, n) end