LintCode Binary Tree Inorder Traversal

Binary Tree Inorder Traversal

Given a binary tree, return the inorder traversal of its nodes' values.

Example

Given binary tree {1,#,2,3},

    1
     \
      2
     /
    3

return [1,3,2].

For in-order traversal we all know that firstly we want to go to the lowest level and most left part to see the node and start from that node because the smallest value of that node in the whole tree. For this problem I have two methods implemented for the question. First one is the basic one which is the recursive method as below. This is pretty straight forward as shown in the description that for each node we traverse left subtree first then visit node then traverse right subtree.

1, The traverse of the node equals traverse left subtree and then visit node, and finally traverse the right subtree.

2, The left sub-tree and right sub-tree are having less problem size than the initial problem.

3, The base case is when the node is null or children of leaves because the recursive part will visit the node before traverse right sub-tree and after traverse of left sub-tree.

 /**
  * Definition of TreeNode:
  * public class TreeNode {
  *     public int val;
  *     public TreeNode left, right;
  *     public TreeNode(int val) {
  *         this.val = val;
  *         this.left = this.right = null;
  *     }
  * }
  */
 public class Solution {
     /**
      * @param root: The root of binary tree.
      * @return: Inorder in ArrayList which contains node values.
      */
     public ArrayList<Integer> inorderTraversal(TreeNode root) {
         // write your code here
         ArrayList<Integer> result = new ArrayList<Integer>();
         traverse(result, root);
         return result;
     }

     public void traverse(ArrayList<Integer> list, TreeNode root) {
         if (root == null) {
             return ;
         }
         traverse(list,root.left);
         list.add(root.val);
         traverse(list,root.right);
     }

 }

The second way of implementation is utilizing the stack to help to iteratively traverse the nodes.

The algorithm is:

Go to the most left as deep as possilble and push all the nodes on the way to the stack

List Result

TreeNode curr;

while

　　curr <---- pop() first element on the top of the stack;

　　add to Result /print the element poped from the stack;

　　while curr.right exist

　　　　curr <---- curr.right

　　　　　　while curr is not nulld

　　　　　　　　push curr to the stack

　　　　　　　　curr <----curr.left

return　(Result)　　　　

 /**
  * Definition of TreeNode:
  * public class TreeNode {
  *     public int val;
  *     public TreeNode left, right;
  *     public TreeNode(int val) {
  *         this.val = val;
  *         this.left = this.right = null;
  *     }
  * }
  */
 public class Solution {
     /**
      * @param root: The root of binary tree.
      * @return: Inorder in ArrayList which contains node values.
      */
     public ArrayList<Integer> inorderTraversal(TreeNode root) {
         // write your code here
         ArrayList<Integer> result = new ArrayList<Integer>();
         Stack<TreeNode> stack = new Stack<TreeNode>();
         TreeNode curr = root;

         if(curr == null) {
             return result;
         }

         while (curr.left != null) {
             stack.push(curr);
             curr = curr.left;
         }

         stack.push(curr);
         while (!stack.isEmpty()) {
             curr= stack.pop();
             result.add(curr.val);
             if (curr.right != null) {
                 curr = curr.right;
                 while (curr.left !=null ) {
                     stack.push(curr);
                     curr=curr.left;
                 }
                 stack.push(curr);
             }
         }
         return result;
     }
 }