Flatten binary tree in order of postorder traversal in ruby

Ruby program for Flatten binary tree in order of postorder traversal. Here more solutions.

#  Ruby program for
#  Flatten binary tree in order of post-order traversal

#  Node of Binary Tree
class TreeNode 
	# Define the accessor and reader of class TreeNode
	attr_reader :data, :left, :right
	attr_accessor :data, :left, :right
	def initialize(data) 
		#  Set node value
		self.data = data
		self.left = nil
		self.right = nil
	end
end

class BinaryTree 
	# Define the accessor and reader of class BinaryTree
	attr_reader :root, :back
	attr_accessor :root, :back
	def initialize() 
		self.root = nil
		self.back = nil
	end

	#  Recursive function
	#  Display postorder view of binary tree
	def postOrder(node) 
		if (node != nil) 
			self.postOrder(node.left)
			self.postOrder(node.right)
			#  Print node value
			print("  ", node.data)
		end
	end

	#  This are flattening tree nodes in postorder from
	def transform(node) 
		if (node != nil) 
			#  Recursive executing left and right subtree
			self.transform(node.left)
			self.transform(node.right)
			if (self.back == nil) 
				#  This is first node of postorder traversal
				#  Get first node of transform tree
				self.root = node
			else
				#  Next node
				self.back.right = node
				#  We taking only one direction
				self.back.left = nil
			end

			self.back = node
		end
	end

	#  This are handling the request of
	#  flatten tree nodes in post order from.
	def flattenNode() 
		if (self.root == nil) 
			#  When empty tree
			return
		end

		#  Set back node
		self.back = nil
		#  Perform flatten operation
		self.transform(self.root)
		if (self.back != nil) 
			#  Set last node of post order
			self.back.left = nil
			self.back.right = nil
		end

		self.back = nil
	end

	#  Display flatten elements of tree
	def showElement() 
		if (self.root == nil) 
			print("\n Empty Tree\n")
			return
		end

		print("\n Flatten Tree Node in Postorder : \n")
		temp = self.root
		#  Iterate tree elements
		while (temp != nil) 
			#  Display node value
			print("  ",temp.data)
			#  Visit to next node
			temp = temp.right
		end
	end
end

def main() 
	#  New tree
	tree = BinaryTree.new()
	#    Construct Binary Tree
	#    -----------------------
	#           1
	#          / \ 
	#         /   \
	#        6     8
	#       / \   / \
	#      2   3 7   5
	#     /   /   \   \
	#    9   4    -6   11
    
	#  Add nodes
	tree.root = TreeNode.new(1)
	tree.root.left = TreeNode.new(6)
	tree.root.left.left = TreeNode.new(2)
	tree.root.right = TreeNode.new(8)
	tree.root.right.right = TreeNode.new(5)
	tree.root.right.left = TreeNode.new(7)
	tree.root.right.left.right = TreeNode.new(-6)
	tree.root.left.right = TreeNode.new(3)
	tree.root.left.right.left = TreeNode.new(4)
	tree.root.left.left.left = TreeNode.new(9)
	tree.root.right.right.right = TreeNode.new(11)
	#  Display tree elements
	print(" Postorder Nodes : \n")
	tree.postOrder(tree.root)
	#  Testing
	tree.flattenNode()
	#  After transform
	tree.showElement()
end

main()

Output

 Postorder Nodes : 
  9  2  4  3  6  -6  7  11  5  8  1
 Flatten Tree Node in Postorder : 
  9  2  4  3  6  -6  7  11  5  8  1