LeetCode 二叉树的中序遍历 (最详细的解法！！！)

给定一个二叉树，返回它的中序 遍历。

示例:

输入: [1,null,2,3]
1

2
/
3

输出: [1,3,2]
进阶: 递归算法很简单，你可以通过迭代算法完成吗？

解题思路：二叉树的中序遍历：左根右。采用递归的思路很简单。直接看代码吧。

代码1：

/**
 * 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) {
         vector<int> res;
         inorder(root, res);
         return res;
     }
     void inorder(TreeNode *root, vector<int> &res) {
         if (!root) 
             return;
         if (root->left) 
             inorder(root->left, res);
         res.push_back(root->val);
         if (root->right) 
             inorder(root->right, res);
     }
 };

代码2

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        if(root){
            inorderTraversal(root->left);
            res.push_back(root->val);
            inorderTraversal(root->right);
        }
        return res;
    }
private:
        vector<int> res;
};

迭代的解题思路1：
从根节点开始，先将根节点压入栈，然后再将其所有左子结点压入栈，然后取出栈顶节点，保存节点值，再将当前指针移到其右子节点上，若存在右子节点，则在下次循环时又可将其所有左子结点压入栈中。这样就保证了访问顺序为左-根-右。

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> s;
        TreeNode *p = root;
        while (!s.empty() || p) {
            if (p) {
                s.push(p);
                p = p->left;
            } else {
                TreeNode *t = s.top(); s.pop();
                res.push_back(t->val);
                p = t->right;
            }
        }
        return res;
    }
};

迭代的解题思路2：
个人觉得没有思路一好。

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> s;
        TreeNode *p = root;
        while (!s.empty() || p) {
            if (p) {
                s.push(p);
                p = p->left;
            } 
            else {
                TreeNode *t = s.top(); 
                s.pop();
                res.push_back(t->val);
                p = t->right;
            }
        }
        return res;
    }
};

迭代的解题思路3：
使用Threaded binary tree，算法如下：1. 初始化指针cur指向root。2. 当cur不为空时，如果cur没有左子结点，a) 打印出cur的值。 b) 将cur指针指向其右子节点。反之，将pre指针指向cur的左子树中的最右子节点，若pre不存在右子节点，a) 将其右子节点指回cur。b) cur指向其左子节点。反之，a) 将pre的右子节点置空。b) 打印cur的值。c) 将cur指针指向其右子节点。

class Solution {
public:
    vector<int> inorderTraversal(TreeNode *root) {
        vector<int> res;
        if (!root) return res;
        TreeNode *cur, *pre;
        cur = root;
        while (cur) {
            if (!cur->left) {
                res.push_back(cur->val);
                cur = cur->right;
            } else {
                pre = cur->left;
                while (pre->right && pre->right != cur) pre = pre->right;
                if (!pre->right) {
                    pre->right = cur;
                    cur = cur->left;
                } else {
                    pre->right = NULL;
                    res.push_back(cur->val);
                    cur = cur->right;
                }
            }
        }
        return res;
    }
};