[C++]LeetCode: 48 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?

Anwser 1: 递归的方法 recursive

思路：中序遍历左子树 --> 显示结点数据，或其他对结点的操作 --> 中序遍历右子树。

算法的时间复杂度是O(n), 而空间复杂度则是递归栈的大小，即O(logn).

Attention：解法二不借助helper函数，需要将res设为全局变量，否则每次递归都会初始化res.

AC Code1 ：（推荐，用helper函数）

<span style="color:#333333;">/**
 * 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) {
        vector<int> res;
        if(root == NULL) return res;
        inorderTraversal_helper(root, res);
        return res;
    }
    
private:
    void inorderTraversal_helper(TreeNode* root, vector<int>& result)
    {
        if(root == NULL) return;
        
        if(root->left != NULL) 
        {
            inorderTraversal_helper(root->left, result);
        }
        
        result.push_back(root->val);
        
        if(root->right != NULL)
        {
            inorderTraversal_helper(root->right, result);
        }
    }
};</span>

AC Code2 :

/**
 * 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> ret;
    vector<int> inorderTraversal(TreeNode *root) {
        //中序遍历树
        if(root == NULL) return ret;
        
        if(root->left != NULL)
        {
            inorderTraversal(root->left);
        }
        
        ret.push_back(root->val);
        
        if(root->right != NULL)
        {
            inorderTraversal(root->right);
        }
        
        return ret;
    }

};

Anwser 2: 迭代的方法 stack+iterative

思路：用一个栈来模拟递归的过程，并且维护一个节点，表示当前走到的节点。用栈来维护递归走过的结点。其他思路和中序遍历思路一样，先左，中，最后右。

算法时间复杂度也是O(n)，空间复杂度是栈的大小O(logn)



Attention： stack<TreeNode*>
TreeS; stack的定义，元素是一个链表， *
不可缺少。

AC Code:

/**
 * 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) {
        vector<int> ret;
        stack<TreeNode*> TreeS;
        
        while(!TreeS.empty() || root != NULL)
        {
            //如果节点没有达到叶子结点，push进stack, 并继续迭代左结点
            if(root != NULL)
            {
                TreeS.push(root);
                root = root->left;
            }
            else
            {
                //如果当前节点为空，则stack内的节点已经无左结点，把父亲节点push进ret，后再遍历父亲节点右子树。
                root = TreeS.top();
                TreeS.pop();
                ret.push_back(root->val);
                root = root->right;
            }
        }      
        return ret;
    }
};

Anwser 3: Morris
Traversal [b]用常量空间来中序遍历一颗二叉树[/b]

[b][待研究][/b]

参考1： Binary
Tree Inorder Traversal -- LeetCode

参考2：Morris
Traversal方法遍历二叉树（非递归，不用栈，O(1)空间）

想用O(1)空间进行遍历，因为不能用栈作为辅助空间来保存付节点的信息，重点在于当访问到子节点的时候如何重新回到父节点（当然这里是指没有父节点指针，如果有其实就比较好办，一直找遍历的后驱结点即可）。Morris遍历方法用了线索二叉树，这个方法不需要为每个节点额外分配指针指向其前驱和后继结点，而是利用叶子节点中的右空指针指向中序遍历下的后继节点就可以了。

步骤：

1. 如果当前节点的左孩子为空，则输出当前节点并将其右孩子作为当前节点。

2. 如果当前节点的左孩子不为空，在当前节点的左子树中找到当前节点在中序遍历下的前驱节点。

a) 如果前驱节点的右孩子为空，将它的右孩子设置为当前节点。当前节点更新为当前节点的左孩子。

b) 如果前驱节点的右孩子为当前节点，将它的右孩子重新设为空（恢复树的形状）。输出当前节点。当前节点更新为当前节点的右孩子。

3. 重复以上1、2直到当前节点为空。

图示：

下图为每一步迭代的结果（从左至右，从上到下），cur代表当前节点，深色节点表示该节点已输出。



Code:

public ArrayList<Integer> inorderTraversal(TreeNode root) {  
    ArrayList<Integer> res = new ArrayList<Integer>();  
    TreeNode cur = root;  
    TreeNode pre = null;  
    while(cur != null)  
    {  
        if(cur.left == null)  
        {  
            res.add(cur.val);  
            cur = cur.right;  
        }  
        else  
        {  
            pre = cur.left;  
            while(pre.right!=null && pre.right!=cur)  
                pre = pre.right;  
            if(pre.right==null)  
            {  
                pre.right = cur;  
                cur = cur.left;  
            }  
            else  
            {  
                pre.right = null;  
                res.add(cur.val);  
                cur = cur.right;  
            }  
        }  
    }  
    return res;  
}

复杂度分析：

空间复杂度：O(1)，因为只用了两个辅助指针。

时间复杂度：O(n)。证明时间复杂度为O(n)，最大的疑惑在于寻找中序遍历下二叉树中所有节点的前驱节点的时间复杂度是多少，即以下两行代码：

1 while (prev->right != NULL && prev->right != cur)
2     prev = prev->right;

直觉上，认为它的复杂度是O(nlgn)，因为找单个节点的前驱节点与树的高度有关。但事实上，寻找所有节点的前驱节点只需要O(n)时间。n个节点的二叉树中一共有n-1条边，整个过程中每条边最多只走2次，一次是为了定位到某个节点，另一次是为了寻找上面某个节点的前驱节点，如下图所示，其中红色是为了定位到某个节点，黑色线是为了找到前驱节点。所以复杂度为O(n)。