LeetCode OJ：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?
中序遍历二叉树，递归遍历当然很容易，题目还要求不用递归，下面给出两种方法：

递归：

 /**
  * Definition for a binary tree node.
  * 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) {
         if(!root) return ret;
         tranverse(root);
         return ret;
     }

     void tranverse(TreeNode * root)
     {
         if(!root) return;
         tranverse(root->left);
         ret.push_back(root->val);
         tranverse(root->right);
     }
 private:
     vector<int> ret;
 };

迭代：

 class Solution {
 public:
     vector<int> inorderTraversal(TreeNode* root) {
         vector<int> ret;
         if(!root) return ret;
         map<TreeNode *, bool> m;
         stack<TreeNode *> s;
         s.push(root);
         while(!s.empty()){
             TreeNode * t = s.top();
             if(t->left && !m[t->left]){
                 m[t->left] = true;
                 s.push(t->left);
                 t = t->left;
                 continue;
             }
             ret.push_back(t->val);
             s.pop();
             if(t->right && !m[t->right]){
                 m[t->right] = true;
                 s.push(t->right);
                 t = t->right;
             }
         }
         return ret;
     }
 };

java版本的代码如下所示，首先是递归版本的代码：

 public class Solution {
     public List<Integer> inorderTraversal(TreeNode root) {
         List<Integer> list = new ArrayList<Integer>();
         recur(list, root);
         return list;
     }

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

再是非递归：

 public class Solution {
     public List<Integer> inorderTraversal(TreeNode root) {
         Stack<TreeNode> s = new Stack<TreeNode>();
         List<Integer> l = new ArrayList<Integer>();
         Map<TreeNode, Integer> m = new HashMap<TreeNode, Integer>();
         if(root != null)
             s.push(root);
         while(!s.empty()){
             TreeNode t = s.peek();
             while(t.left != null && !m.containsKey(t.left)){
                 s.push(t.left);
                 m.put(t.left, );
                 t = t.left;
             }
             s.pop();
             l.add(t.val);
             if(t.right != null && !m.containsKey(t.right)){
                 s.push(t.right);
                 m.put(t.right, );
             }
         }
         return l;
     }
 }