Binary Search Tree Insertion method in Ruby - ruby

Question

I'm working on data structures and I got stuck on one of the challenges. The objective is to insert array elements into a binary search tree based on their value i.e ( the root_node of the main tree is array[0], the left subtree's root_node is less than the parent node, and the right subtree's root_node is greater than the parent node). This is to be done recursively until all array elements are inserted into the BST.
I have implemented two classes:
That represents the node with attributes ( data, left, right):
class Node
attr_reader :data
attr_accessor :left, :right
def initialize(data)
#data = data
end
end
The BST class to represent the binary search tree with the root value set to nil:
class BST
attr_accessor :root
def initialize
#root = nil
end
def insert(node)
insert_node(#root, node)
end
def pre_order(node = #root)
return '' if node.nil?
print "#{node.data} "
pre_order(node.left)
pre_order(node.right)
end
private
def insert_node(node, element)
if node.nil?
node = element
elsif node.data > element.data
node.left = insert_node(node.left, element)
else
node.right = insert_node(node.right, element)
end
node
end
end
The insert_node is a private method for BST which does the actual work to insert a node to the tree. I separated it from insert because of the requirements for the expected solution which gets evaluated using RSpec.
I then did a pre_order traversal to print each Node to the terminal window.
I have a binary_search_tree method which accepts an array as input and calls the insert method on each array element. It's main functionality is to convert an array to a binary tree and print out all the tree nodes in pre_order format.
def binary_search_tree(array)
tree = BST.new
array.each { |e| tree.insert(Node.new(e)) }
tree.pre_order
end
If I run the binary_search_tree method with [8, 3, 10, 1, 6, 14, 4, 7, 13] as an argument, I expect to get the nodes printed out in the format # => "8 3 1 6 4 7 10 14 13" but nothing is happening and I don't know where I might have gone wrong. I have been stuck on this challenge for hours today, if anyone could assist that will mean a lot. Thanks : )
sample input:
puts binary_search_tree([8, 3, 10, 1, 6, 14, 4, 7, 13])
expected output:
8 3 1 6 4 7 10 14 13
got:

Answer 1

Oh, I finally found a way around the challenge. I'm just gonna demonstrate how I did it for future reference:
So, instead of using two separate methods insert and insert_helper node, I decided to get rid of the redundant code and came up with one method to solve the challenge. Here's the BST class structure:
class BST
attr_accessor :root
def initialize
#root = nil
end
def insert(node, head = #root)
return #root = node if #root.nil?
return node if head.nil?
if node.data < head.data
head.left = insert(node, head.left)
elsif node.data > head.data
head.right = insert(node, head.right)
end
head
end
def pre_order(node = #root)
return '' if node.nil?
result = ''
result += "#{node.data} "
result += pre_order(node.left)
result += pre_order(node.right)
end
end
The insert method now accepts two parameters node and ( head which is an optional parameter ), to allow us to perform recursive operations on the subtree nodes and yield the desired result.
pre_order prints each node's data, this is done in the recursive approach so each node in the Binary Search Tree gets printed out in pre_order format.
Now if you call the BST pre_order method for example:
def binary_search_tree(array)
tree = BST.new
array.each { |e| tree.insert(Node.new(e)) }
tree.pre_order
end
puts binary_search_tree([8, 3, 10, 1, 6, 14, 4, 7, 13])
you get the result 8 3 1 6 4 7 10 14 13. By altering the pre_order method, you can print the tree nodes in post_order, inorder, e.t.c.
I hope this will be useful for the others. Happy coding!!

Answer 2

return '' if node.nil?
This is the stop condition of the recursive pre_order and it's what you return from binary_search_tree. You don't seem to have anything that would format your tree in your desired shape, "8 3 1 6 4 7 10 14 13". So add that logic and call it at the end of binary_search_tree method.