Leetcode 94 - 二叉树的中序遍历

1 题目

https://leetcode-cn.com/problems/binary-tree-inorder-traversal/

2 题意

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

示例:

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

输出: [1,3,2]

进阶: 递归算法很简单，你可以通过迭代算法完成吗?

3 思路

author's blog == http://www.cnblogs.com/toulanboy/

3.1 中序遍历

对于一颗树，先访问左子树，再访问根节点，最后访问右子树

3.2 递归解法

直接写一个函数，负责当前树的遍历。空树就是边界。

3.3 非递归解法

大体思路是使用栈模拟递归过程，实现中序遍历的次序要求。

更具体描述为：

（1）对于一颗树，依次把右子树、根、左子树进栈。这样出栈时便满足中序遍历。

（2）从栈里面取出顶点，不停进行把右子树、根、左子树进栈的过程。

（3）当栈为空，即说明所有节点遍历完毕。

4 代码实现

4.1 递归代码

//author's blog == http://www.cnblogs.com/toulanboy/
/**
 * 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> ans;
    void inorder(TreeNode* root){
        if(!root)
            return;
        inorder(root->left);//先遍历左子树
        ans.push_back(root->val);//再遍历根节点
        inorder(root->right);//最后遍历右子树
    }
    vector<int> inorderTraversal(TreeNode* root) {
        inorder(root);
        return ans;
    }
};

4.2 非递归代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
//author's blog == http://www.cnblogs.com/toulanboy/
class Solution {
public:
    
    vector<int> inorder(TreeNode* root){
        vector<int> ans;
        stack<TreeNode*> order;
        if(root == NULL)
            return ans;

        if(root->right) //先塞右子树
            order.push(root->right);
        order.push(new TreeNode(root->val));//再塞根
        if(root->left) //最后塞左子树
            order.push(root->left);

        TreeNode* temp;
        while(!order.empty()){
            temp = order.top();
            order.pop();
            //如果这个点是根或者是叶子，直接输出
            if(temp->left == NULL && temp->right == NULL){
                ans.push_back(temp->val);
            }
            else{//否则说明这个树还有子树，还需要进行左右遍历
                if(temp->right) //先塞右子树
                    order.push(temp->right);
                order.push(new TreeNode(temp->val));//再塞根
                if(temp->left) //最后塞左子树
                    order.push(temp->left);
            }
        }
        return ans;
    }
    vector<int> inorderTraversal(TreeNode* root) {
        return inorder(root);
    }
};