Hi, guys.
I'm writing a Node class for a Binary Tree.
Coding comes below.
There's a method remove_leaf.
Now I want to do it this way:
=begin
[@left_node, @right_node].each do |node|
if node.is_leaf?
node = nil
end
end
=end
But it doesn't work.
Is there a way to do it ?
You can ignore class Tree. I just post it here to make a little sense.
···
---------- Forwarded message ----------
From: salamond <jarodzz@gmail.com>
Date: Wed, Oct 13, 2010 at 9:12 AM
Subject: ruby-talk-ask
To: jarodzz@gmail.com
class Node
attr_accessor :value, :left_node, :right_node
def initialize(value=nil, left_node=nil, right_node=nil)
@value = value
@left_node = left_node
@right_node = right_node
end
def to\_s
@value\.to\_s
end
def is\_leaf?
return @left\_node==nil && @right\_node==nil
end
def remove\_leaf
if is\_leaf?
return
else
=begin
[@left_node, @right_node].each do |node|
if node.is_leaf?
node = nil
end
end
=end
if @left_node.is_leaf?
@left_node = nil
end
if @right_node.is_leaf?
@right_node = nil
end
end
end
end
require 'test/unit'
require 'node'
class NodeTest < Test::Unit::TestCase
def setup
@empty = Node.new()
@single = Node.new("haha")
@full = Node.new(1, Node.new(2), Node.new(4))
end
def test\_default\_init\(\)
assert\(@empty\.value==nil\)
assert\(@empty\.left\_node==nil\)
assert\(@empty\.right\_node==nil\)
end
def test\_init\_with\_value\(\)
assert\(@full\.left\_node\.value==2\)
assert\(@full\.right\_node\.value==4\)
assert\(@full\.value==1\)
end
def test\_to\_s\(\)
assert\(@full\.to\_s == "1"\)
assert\(@single\.to\_s == "haha"\)
end
def test\_is\_leaf\(\)
assert\(@empty\.is\_leaf? == true\)
assert\(@single\.is\_leaf? == true\)
assert\(@full\.is\_leaf? == false\)
end
def test\_remove\_leaf\(\)
assert\(@full\.is\_leaf? == false\)
@full\.remove\_leaf\(\)
assert\(@full\.is\_leaf? == true\)
end
end
require "node"
class Tree
attr_accessor :root, :nodes, :sorted_nodes
def initialize( root=nil )
@root = root
@nodes = Array.new()
if @root!= nil
@nodes.push( @root )
end
@sorted_nodes = Array.new()
@targets = Array.new()
end
def insert( node )
@nodes.push( node )
@root = insert_at( @root, node )
end
# TODO: to prevent multiple travel in the same way, add state check
def travel(order = :inorder)
@sorted_nodes = Array.new()
travel_at( @root, order )
return @sorted_nodes
end
def to_s
@data.to_s
end
def cut_all_leaves()
@nodes.each do |node|
node.cut_leaf
end
end
def n_step_from_leaf( n )
(1..n).each do |times|
cut_all_leaves
end
nodes = Array.new()
travel().each do |node|
if node.is_leaf?
nodes.push(node)
end
end
return nodes
end
private
def insert_at(subroot, node)
if subroot == nil
subroot = node
else
if subroot.value >= node.value
subroot.left_node = insert_at(subroot.left_node, node)
else
subroot.right_node = insert_at(subroot.right_node, node)
end
end
return subroot
end
def travel_at(subroot, order)
if subroot == nil
return
end
case order
when :preorder
@sorted_nodes.push( subroot )
travel_at( subroot.left_node, order )
travel_at( subroot.right_node, order )
when :inorder
travel_at( subroot.left_node, order)
@sorted_nodes.push( subroot )
travel_at( subroot.right_node, order )
when :postorder
travel_at( subroot.left_node, order )
travel_at( subroot.right_node, order)
@sorted_nodes.push( subroot )
end
end
end
