Change binary tree traversal implementation and add the test (#360)

* add btree test file

* change binary tree traversal implementation and add btree traversal test

Co-authored-by: Rak Laptudirm <[email protected]>

Author: FemiNoviaLina

structure/binarytree/btree.go

@@ -1,7 +1,5 @@
 package binarytree
 
-import "fmt"
-
 // BTree Returns a binary tree structure which contains only a root Node
 type BTree struct {
 	Root *Node
@@ -33,15 +31,6 @@ func (t *BTree) Depth() int {
 	return calculateDepth(t.Root, 0)
 }
 
-// InOrder add's children to a node in order left first then right recursively
-func InOrder(n *Node) {
-	if n != nil {
-		InOrder(n.left)
-		fmt.Print(n.val, " ")
-		InOrder(n.right)
-	}
-}
-
 // InOrderSuccessor Goes to the left
 func InOrderSuccessor(root *Node) *Node {
 	cur := root
@@ -77,36 +66,63 @@ func BstDelete(root *Node, val int) *Node {
 	return root
 }
 
+// InOrder add's children to a node in order left first then right recursively
+func inOrderRecursive(n *Node, traversal *[]int) {
+	if n != nil {
+		inOrderRecursive(n.left, traversal)
+		*traversal = append(*traversal, n.val)
+		inOrderRecursive(n.right, traversal)
+	}
+}
+
+func InOrder(root *Node) []int {
+	traversal := make([]int, 0)
+	inOrderRecursive(root, &traversal)
+	return traversal
+}
+
 // PreOrder Preorder
-func PreOrder(n *Node) {
+func preOrderRecursive(n *Node, traversal *[]int) {
 	if n == nil {
 		return
 	}
-	fmt.Print(n.val, " ")
-	PreOrder(n.left)
-	PreOrder(n.right)
+	*traversal = append(*traversal, n.val)
+	preOrderRecursive(n.left, traversal)
+	preOrderRecursive(n.right, traversal)
+}
+
+func PreOrder(root *Node) []int {
+	traversal := make([]int, 0)
+	preOrderRecursive(root, &traversal)
+	return traversal
 }
 
 // PostOrder PostOrder
-func PostOrder(n *Node) {
+func postOrderRecursive(n *Node, traversal *[]int) {
 	if n == nil {
 		return
 	}
-	PostOrder(n.left)
-	PostOrder(n.right)
-	fmt.Print(n.val, " ")
+	postOrderRecursive(n.left, traversal)
+	postOrderRecursive(n.right, traversal)
+	*traversal = append(*traversal, n.val)
+}
+
+func PostOrder(root *Node) []int {
+	traversal := make([]int, 0)
+	postOrderRecursive(root, &traversal)
+	return traversal
 }
 
 // LevelOrder LevelOrder
-func LevelOrder(root *Node) {
+func levelOrderRecursive(root *Node, traversal *[]int) {
 	var q []*Node // queue
 	var n *Node   // temporary node
 
 	q = append(q, root)
 
 	for len(q) != 0 {
 		n, q = q[0], q[1:]
-		fmt.Print(n.val, " ")
+		*traversal = append(*traversal, n.val)
 		if n.left != nil {
 			q = append(q, n.left)
 		}
@@ -116,6 +132,12 @@ func LevelOrder(root *Node) {
 	}
 }
 
+func LevelOrder(root *Node) []int {
+	traversal := make([]int, 0)
+	levelOrderRecursive(root, &traversal)
+	return traversal
+}
+
 // AccessNodesByLayer Function that access nodes layer by layer instead of printing the results as one line.
 func AccessNodesByLayer(root *Node) [][]int {
 	var res [][]int

structure/binarytree/btree_test.go

@@ -124,6 +124,94 @@ func TestDelete(t *testing.T) {
 	})
 }
 
+func TestInOrder(t *testing.T) {
+	BTree := BTree{
+		Root: NewNode(90),
+	}
+
+	root := BTree.Root
+
+	Insert(root, 80)
+	Insert(root, 100)
+	Insert(root, 70)
+	Insert(root, 85)
+	Insert(root, 95)
+	Insert(root, 105)
+
+	a := InOrder(root)
+	b := []int{70, 80, 85, 90, 95, 100, 105}
+
+	if !reflect.DeepEqual(a, b) {
+		t.Errorf("Nodes should have value = [70 80 85 90 95 100 105]")
+	}
+}
+
+func TestPreOrder(t *testing.T) {
+	BTree := BTree{
+		Root: NewNode(90),
+	}
+
+	root := BTree.Root
+
+	Insert(root, 80)
+	Insert(root, 100)
+	Insert(root, 70)
+	Insert(root, 85)
+	Insert(root, 95)
+	Insert(root, 105)
+
+	a := PreOrder(root)
+	b := []int{90, 80, 70, 85, 100, 95, 105}
+
+	if !reflect.DeepEqual(a, b) {
+		t.Errorf("Nodes should have value = [90 80 70 85 100 95 105]")
+	}
+}
+
+func TestPostOrder(t *testing.T) {
+	BTree := BTree{
+		Root: NewNode(90),
+	}
+
+	root := BTree.Root
+
+	Insert(root, 80)
+	Insert(root, 100)
+	Insert(root, 70)
+	Insert(root, 85)
+	Insert(root, 95)
+	Insert(root, 105)
+
+	a := PostOrder(root)
+	b := []int{70, 85, 80, 95, 105, 100, 90}
+
+	if !reflect.DeepEqual(a, b) {
+		t.Errorf("Nodes should have value = [70 85 80 95 105 100 90]")
+	}
+}
+
+func TestLevelOrder(t *testing.T) {
+	BTree := BTree{
+		Root: NewNode(90),
+	}
+
+	root := BTree.Root
+
+	Insert(root, 80)
+	Insert(root, 100)
+	Insert(root, 70)
+	Insert(root, 85)
+	Insert(root, 95)
+	Insert(root, 105)
+
+	a := LevelOrder(root)
+	b := []int{90, 80, 100, 70, 85, 95, 105}
+
+	if !reflect.DeepEqual(a, b) {
+		t.Errorf("Nodes should have value = [90 80 100 70 85 95 105]")
+	}
+}
+
 func TestAccessNodesByLayer(t *testing.T) {
 	BTree := BTree{
 		Root: NewNode(90),