postorder traverse

Author: vfedorovatlas

binary-tree-postorder-traversal/Readme.md

@@ -0,0 +1,3 @@
+# Problem: 135.   Binary Tree Postorder Traversal
+
+Post-order traversal is to traverse the left subtree first. Then traverse the right subtree. Finally, visit the root.

binary-tree-postorder-traversal/main.go

@@ -0,0 +1,78 @@
+package binarytreepostordertraversal
+
+// TreeNode data structure
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+// Stack data structure that implements LIFO
+type Stack []*TreeNode
+
+// Push adds an item onto the stack.
+func (s *Stack) Push(node *TreeNode) {
+	*s = append(*s, node)
+}
+
+// Pop removes the most-recently-pushed item from the stack.
+func (s *Stack) Pop() *TreeNode {
+	arr := *s
+	last := len(arr) - 1
+	top := arr[last]
+	if len(arr) > 0 {
+		arr = arr[0:last]
+	} else {
+		arr = []*TreeNode{}
+	}
+	*s = arr
+	return top
+}
+
+// Peek a top element
+func (s *Stack) Peek() *TreeNode {
+	arr := *s
+	if len(arr) == 0 {
+		return nil
+	}
+	last := len(arr) - 1
+	top := arr[last]
+	return top
+}
+
+// Nice explanation: https://www.geeksforgeeks.org/iterative-postorder-traversal-using-stack/
+func postorderTraversal(root *TreeNode) []int {
+	ret := []int{}
+	if root == nil {
+		return ret
+	}
+	stack := Stack{}
+	for {
+		// Push root's right child and then root to stack
+		for root != nil {
+			if root.Right != nil {
+				stack.Push(root.Right)
+			}
+			stack.Push(root)
+			// Set root as root's left child
+			root = root.Left
+		}
+		// Pop an item from stack and set it as root
+		root = stack.Pop()
+		// If the popped item has a right child and the
+		// right child is not processed yet, then make sure
+		// right child is processed before root
+		if root.Right != nil && stack.Peek() == root.Right {
+			stack.Pop()       //Remove right child from stack
+			stack.Push(root)  //Push root back to stack
+			root = root.Right // change root so that the right childis processed next
+		} else { // Else print root's data and set root as None
+			ret = append(ret, root.Val)
+			root = nil
+		}
+		if len(stack) <= 0 {
+			break
+		}
+	}
+	return ret
+}

binary-tree-postorder-traversal/main_test.go

@@ -0,0 +1,50 @@
+package binarytreepostordertraversal
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestPostorderTraversal(t *testing.T) {
+	testCases := []struct {
+		Input  *TreeNode
+		Output []int
+	}{
+		{
+			Input: &TreeNode{
+				Val:  1,
+				Left: nil,
+				Right: &TreeNode{
+					Val: 2,
+					Left: &TreeNode{
+						Val: 3,
+					},
+				},
+			},
+			Output: []int{3, 2, 1},
+		},
+		{
+			Input:  nil,
+			Output: []int{},
+		},
+		{
+			Input: &TreeNode{
+				Val: 3,
+				Left: &TreeNode{
+					Val: 1,
+					Right: &TreeNode{
+						Val: 2,
+					},
+				},
+			},
+			Output: []int{2, 1, 3},
+		},
+	}
+
+	for _, test := range testCases {
+		out := postorderTraversal(test.Input)
+		if !reflect.DeepEqual(test.Output, out) {
+			t.Errorf("expected to get %#v, but got %#v", test.Output, out)
+		}
+	}
+}