LeetCode94. 二叉树的中序遍历

94. 二叉树的中序遍历

一、题目

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

示例 1：

输入：root = [1,null,2,3]
输出：[1,3,2]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

提示：

• 树中节点数目在范围 [0, 100] 内
• -100 <= Node.val <= 100

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

二、思路及代码

（1）递归（比较简单）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> v;
    vector<int> inorderTraversal(TreeNode* root) {
        if(root!=NULL){
            inorderTraversal(root->left);
            v.push_back(root->val);
            inorderTraversal(root->right);
        }
        return v;
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void Traversal(TreeNode *root, vector<int> &vec){
        if(root == NULL){
            return;
        }
        Traversal(root->left, vec);
        vec.push_back(root->val);
        Traversal(root->right,vec);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        Traversal(root, result);
        return result;
    }
};

（2）迭代

算法思路

中序遍历的顺序是左子树->根节点->右子树。想要以这个顺序遍历整棵树,可以使用栈的结构助于遍历。

1. 定义一个栈和结果数组。
2. 从根节点开始,连续将左子节点入栈,直到为空为止。
3. 出栈栈顶元素,将出栈节点的值添加到结果数组。
4. 将右子节点作为当前节点,重复步骤2和3,直到栈空且当前节点为空。

这样通过栈的结构可以保证每次都是从最左子节点顺序返回根节点,从而实现中序遍历。

具体实现

1. 定义栈和结果数组result。
2. 将根节点root作为当前节点进入while循环。
3. 当前节点不为空时,将其入栈,并移动到其左子节点。
4. 当前节点为空时,说明左子树遍历完毕,出栈,将出栈节点的值添加到result,并将当前节点移动到右子节点。
5. 重复步骤3和4,直到栈空且当前节点为空,遍历结束。
6. 返回结果数组result。

class Solution {
public:
  vector<int> inorderTraversal(TreeNode* root) {
    // 结果数组
    vector<int> result; 
    // 栈存储节点指针
    stack<TreeNode*> st;
    // 当前节点初始化为根节点
    TreeNode* node = root; 

    // 当节点或栈非空时循环
    while (node != nullptr || !st.empty()) {
      // 当前节点不为空,持续左子节点入栈
      if (node != nullptr) {
        st.push(node);
        node = node->left;  
      } 
      // 当前节点为空,说明左子树遍历完毕
      else {
        // 出栈顶节点,访问节点值     
        TreeNode* temp = st.top();
        result.push_back(temp->val);
        st.pop();
        // 将当前节点更新为右子节点
        node = temp->right;   
      }
    }
    return result;
  }
}

算法分析

• 时间复杂度:O(n),其中 n 为二叉树节点数。需要遍历所有节点。
• 空间复杂度:O(n),其中 n 为二叉树节点数。栈的空间复杂度为 O(n)。