From 965bac0ef35e8e776f64ae471759d4796a8bba05 Mon Sep 17 00:00:00 2001 From: Haben Date: Mon, 31 Aug 2020 00:22:12 -0700 Subject: [PATCH 1/3] add methods to add/find & traverse --- lib/tree.rb | 189 +++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 166 insertions(+), 23 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index c0d4b51..81ab227 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -1,66 +1,209 @@ +# frozen_string_literal: true + class TreeNode attr_reader :key, :value attr_accessor :left, :right - def initialize(key, val) + def initialize(key, val) @key = key @value = val @left = nil @right = nil - end + end end class Tree attr_reader :root + def initialize @root = nil end - # Time Complexity: - # Space Complexity: + def print_root(node = @root) + if node.nil? + puts 'root is niiiiiiiiil' + else + puts node.value + puts node.key + end + end + + # def add_recursive(current, key, value) + # if current.nil? + # current = TreeNode.new(key, value) + # return + # elsif key < current.key + # if current.left = nil + # current.left = TreeNode.new(key, value) + # else + # add_recursive(current.left, key, value) + # end + # elsif key >= current.key + # if current.right = nil + # current.right = TreeNode.new(key, value) + # else + # add_recursive(current.right, key, value) + # end + # end + # end + + # Time Complexity: + # Space Complexity: def add(key, value) - raise NotImplementedError + current_node = @root + + @root = TreeNode.new(key, value) if current_node.nil? + + until current_node.nil? + if (key < current_node.key) && current_node.left.nil? + current_node.left = TreeNode.new(key, value) + elsif (key > current_node.key) && current_node.right.nil? + current_node.right = TreeNode.new(key, value) + elsif key < current_node.key + current_node = current_node.left + elsif key > current_node.key + current_node = current_node.right + else + return + end + end + end + + # Time Complexity: + # Space Complexity: + + def find_recursive(current, key) + return nil if current.nil? + + return current.value if key == current.key + + if key < current.key + find_recursive(current.left, key) + elsif key > current.key + find_recursive(current.right, key) + end end - # Time Complexity: - # Space Complexity: def find(key) - raise NotImplementedError + find_recursive(@root, key) + end + + # Time Complexity: + # Space Complexity: + + def inorder_recursion(current, traverse_array) + return if current.nil? + + inorder_recursion(current.left, traverse_array) # process left side + + traverse_array << { key: current.key, value: current.value } + + inorder_recursion(current.right, traverse_array) # process right side end - # Time Complexity: - # Space Complexity: def inorder - raise NotImplementedError + traverse_array = [] + + inorder_recursion(@root, traverse_array) + + traverse_array + end + + # Time Complexity: + # Space Complexity: + def preorder_recursion(current, traverse_array) + return if current.nil? + + traverse_array << { key: current.key, value: current.value } + preorder_recursion(current.left, traverse_array) # process left side + preorder_recursion(current.right, traverse_array) # process right side end - # Time Complexity: - # Space Complexity: def preorder - raise NotImplementedError + traverse_array = [] + + preorder_recursion(@root, traverse_array) + + traverse_array + end + + # Time Complexity: + # Space Complexity: + def postorder_recursion(current, traverse_array) + return if current.nil? + + postorder_recursion(current.left, traverse_array) # process left side + postorder_recursion(current.right, traverse_array) # process right side + traverse_array << { key: current.key, value: current.value } end - # Time Complexity: - # Space Complexity: def postorder - raise NotImplementedError + traverse_array = [] + + postorder_recursion(@root, traverse_array) + + traverse_array end - # Time Complexity: - # Space Complexity: + # Time Complexity: + # Space Complexity: + + # def height(node) + # return 0 if node.nil? + + # leftHeight = height(node.left) + # return -1 if leftHeight == -1 + + # rightHeight = height(node.right) + # return -1 if rightHeight == -1 + + # diff = leftHeight - rightHeight + # if diff.abs > 1 + # -1 + # else + # [leftHeight, rightHeight].max + 1 + # end + # end + + # def is_balanced?(node = @root) + # check_height(node) != -1 + # end + def height - raise NotImplementedError + count_right = 0 + count_left = 0 + node = @root + return count_left if node.nil? + + count_left = height_helper(node, 'left', count_left) + count_right = height_helper(node, 'right', count_right) + if count_right > count_left + count_right + else + count_left + end + end + + def height_helper(node, side, count) + return count if node.nil? + + count += 1 + if side == 'left' + height_helper(node.left, 'left', count) + else + height_helper(node.right, 'right', count) + end end # Optional Method - # Time Complexity: - # Space Complexity: + # Time Complexity: + # Space Complexity: def bfs raise NotImplementedError end # Useful for printing def to_s - return "#{self.inorder}" + inorder.to_s end end From f6e4de840f906ba1727c9901cd963834362a8a62 Mon Sep 17 00:00:00 2001 From: Haben Date: Mon, 31 Aug 2020 22:50:38 -0700 Subject: [PATCH 2/3] clean comments --- lib/tree.rb | 72 ++++++++++++----------------------------------------- 1 file changed, 16 insertions(+), 56 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index 81ab227..1fce0ac 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -21,31 +21,13 @@ def initialize def print_root(node = @root) if node.nil? - puts 'root is niiiiiiiiil' + puts 'root is nil' else puts node.value puts node.key end end - # def add_recursive(current, key, value) - # if current.nil? - # current = TreeNode.new(key, value) - # return - # elsif key < current.key - # if current.left = nil - # current.left = TreeNode.new(key, value) - # else - # add_recursive(current.left, key, value) - # end - # elsif key >= current.key - # if current.right = nil - # current.right = TreeNode.new(key, value) - # else - # add_recursive(current.right, key, value) - # end - # end - # end # Time Complexity: # Space Complexity: @@ -69,8 +51,8 @@ def add(key, value) end end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) + # Space Complexity: O(n) def find_recursive(current, key) return nil if current.nil? @@ -88,17 +70,17 @@ def find(key) find_recursive(@root, key) end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) + # Space Complexity: O(n) def inorder_recursion(current, traverse_array) return if current.nil? - inorder_recursion(current.left, traverse_array) # process left side + inorder_recursion(current.left, traverse_array) traverse_array << { key: current.key, value: current.value } - inorder_recursion(current.right, traverse_array) # process right side + inorder_recursion(current.right, traverse_array) end def inorder @@ -109,15 +91,14 @@ def inorder traverse_array end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) + # Space Complexity: O(n) def preorder_recursion(current, traverse_array) return if current.nil? traverse_array << { key: current.key, value: current.value } - preorder_recursion(current.left, traverse_array) # process left side - preorder_recursion(current.right, traverse_array) # process right side - end + preorder_recursion(current.left, traverse_array) + preorder_recursion(current.right, traverse_array) def preorder traverse_array = [] @@ -127,13 +108,13 @@ def preorder traverse_array end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) + # Space Complexity: O(n) def postorder_recursion(current, traverse_array) return if current.nil? - postorder_recursion(current.left, traverse_array) # process left side - postorder_recursion(current.right, traverse_array) # process right side + postorder_recursion(current.left, traverse_array) + postorder_recursion(current.right, traverse_array) traverse_array << { key: current.key, value: current.value } end @@ -145,30 +126,9 @@ def postorder traverse_array end - # Time Complexity: + # Time Complexity: # Space Complexity: - # def height(node) - # return 0 if node.nil? - - # leftHeight = height(node.left) - # return -1 if leftHeight == -1 - - # rightHeight = height(node.right) - # return -1 if rightHeight == -1 - - # diff = leftHeight - rightHeight - # if diff.abs > 1 - # -1 - # else - # [leftHeight, rightHeight].max + 1 - # end - # end - - # def is_balanced?(node = @root) - # check_height(node) != -1 - # end - def height count_right = 0 count_left = 0 From bd7def7cb7f89a7f9781500a0316446e3919aeec Mon Sep 17 00:00:00 2001 From: Haben Date: Mon, 31 Aug 2020 22:57:44 -0700 Subject: [PATCH 3/3] add end --- lib/tree.rb | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/lib/tree.rb b/lib/tree.rb index 1fce0ac..c4b9518 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -99,6 +99,7 @@ def preorder_recursion(current, traverse_array) traverse_array << { key: current.key, value: current.value } preorder_recursion(current.left, traverse_array) preorder_recursion(current.right, traverse_array) + end def preorder traverse_array = [] @@ -126,7 +127,7 @@ def postorder traverse_array end - # Time Complexity: + # Time Complexity: # Space Complexity: def height