LeetCode - Binary Tree Inorder Traversal

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

For example:
Given binary tree {1,#,2,3},

   1
    \
     2
    /
   3

return [1,3,2].

Note: Recursive solution is trivial, could you do it iteratively?

confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

OJ's Binary Tree Serialization:

The serialization of a binary tree follows a level order traversal, where '#' signifies a path terminator where no node exists below.

Here's an example:

   1
  / \
 2   3
    /
   4
    \
     5

The above binary tree is serialized as  "{1,2,3,#,#,4,#,#,5}".

http://oj.leetcode.com/problems/binary-tree-inorder-traversal/

Solution:

Inorder, postorder and preorder traversal are the must-known in technical interview. And they are very similiar in recursive way. The only difference is the order of push nodes into vector.

I also provide a iterative way.

https://github.com/starcroce/leetcode/blob/master/binary_tree_inorder_traversal.cpp

// 16 milli secs for large judge
/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> inorderTraversal(TreeNode *root) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        vector<int> ans;
        if (root == NULL) {
            return ans;
        }
        vector<int> left = inorderTraversal(root->left);
        vector<int> right = inorderTraversal(root->right);
        // inorder is left, root, right; preorder is root, left, right; postorder is left, right, root
        for (int i = 0; i < left.size(); i++) {
            ans.push_back(left[i]);
        }
        ans.push_back(root->val);
        for (int i = 0; i < right.size(); i++) {
            ans.push_back(right[i]);
        }
        return ans;
    }
};

// non-recursive
// 8 ms for 67 test cases
vector<int> inorderTraversal(TreeNode *root){
    vector<int> ans;
    vector<TreeNode *> s;
    if(root == NULL){
        return ans;
    }
    TreeNode *current = root;
    while(!s.empty() || current){
        // move to the most left node of the current tree
        // the path is the most left edge
        while(current){
            s.push_back(current);
            current = current->left;
        }
        current = s.back();
        s.pop_back();
        ans.push_back(current->val);
        // the right child of current node is the next node in inorder traversal
        current = current->right;
    }
    return ans;
}