LeetCode 热题 100—— 二叉树的中序遍历(二叉树）+ 二叉树的最大深度（二叉树）

目录

二叉树

94. 二叉树的中序遍历 简单

104. 二叉树的最大深度 简单

---

二叉树

94. 二叉树的中序遍历 简单

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

• 树中节点数目在范围 [0, 100] 内

• -100 <= Node.val <= 100

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

//方法一：递归
//定义 inorder(root) 表示当前遍历到 root 节点的答案，那么按照定义，我们只要递归调用 inorder(root.left) 来遍历 root 节点的左子树，然后将 root 节点的值加入答案，再递归调用inorder(root.right) 来遍历 root 节点的右子树即可，递归终止的条件为碰到空节点。
​
//时间复杂度：O(n)，其中 n 为二叉树节点的个数。二叉树的遍历中每个节点会被访问一次且只会被访问一次。
//空间复杂度：O(n)。空间复杂度取决于递归的栈深度，而栈深度在二叉树为一条链的情况下会达到 O(n) 的级别。
​
class Solution {
public:
    //！！！！！！！！！注意res容器地址的传入 要不然结果不对！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
    void inorder(TreeNode* root, vector<int>& res) {
        //当当前节点 root 为空时，递归返回
        if (!root) {
            return;
        }
        // 递归遍历左子树
        inorder(root->left, res);
        // 访问当前节点（根节点）
        res.push_back(root->val);
        // 递归遍历右子树
        inorder(root->right, res);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        // 初始化结果数组
        vector<int> res;
        // 调用递归函数开始遍历
        inorder(root, res);
        // 返回结果数组
        return res;
    }
};
​

//方法二：迭代
//方法一的递归函数我们也可以用迭代的方式实现，两种方式是等价的，区别在于递归的时候隐式地维护了一个栈，而我们在迭代的时候需要显式地将这个栈模拟出来，其他都相同，具体实现可以看下面的代码。
​
//时间复杂度：O(n)，其中 n 为二叉树节点的个数。二叉树的遍历中每个节点会被访问一次且只会被访问一次。
//空间复杂度：O(n)。空间复杂度取决于栈深度，而栈深度在二叉树为一条链的情况下会达到 O(n) 的级别。
​
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        //存储遍历结果的数组。
        vector<int> res;
        //辅助栈，用于存储待访问的节点。
        stack<TreeNode*> stk;
        while (root != nullptr || !stk.empty()) {
            // 步骤1：遍历左子树，将所有左节点压入栈
            //这确保了左子树的节点按深度优先顺序被压入栈。
            while (root != nullptr) {
                //循环将当前节点 root 及其所有左子节点压入栈，直到左子树为空（root == nullptr）。
                stk.push(root);
                root = root->left;
            }
            
            // 步骤2：弹出栈顶节点（当前最左侧节点），访问其值
            root = stk.top();
            stk.pop();
            //将其值加入结果数组 res
            res.push_back(root->val);
            
            // 步骤3：转向右子树
            //将 root 指向弹出节点的右子树，重复上述过程。
            //若右子树为空，下次循环会继续从栈中弹出节点。
            root = root->right;
        }
        return res;
    }
};

//方法三：Morris 中序遍历
​
/*
Morris 遍历算法整体步骤如下（假设当前遍历到的节点为 x）：
1. 如果 x 无左孩子，先将 x 的值加入答案数组，再访问 x 的右孩子，即 x=x.right。
2. 如果 x 有左孩子，则找到 x 左子树上最右的节点（即左子树中序遍历的最后一个节点，x 在中序遍历中的前驱节点），我们记为 predecessor。根据 predecessor 的右孩子是否为空，进行如下操作。
--如果 predecessor 的右孩子为空，则将其右孩子指向 x，然后访问 x 的左孩子，即 x=x.left。
--如果 predecessor 的右孩子不为空，则此时其右孩子指向 x，说明我们已经遍历完 x 的左子树，我们将 predecessor 的右孩子置空，将 x 的值加入答案数组，然后访问 x 的右孩子，即 x=x.right。
*/
​
​
//时间复杂度：O(n)，其中 n 为二叉树的节点个数。Morris 遍历中每个节点会被访问两次，因此总时间复杂度为 O(2n)=O(n)。
//空间复杂度：O(1)。
​
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        //predecessor：用于寻找当前节点的前驱节点（左子树的最右节点）。
        TreeNode *predecessor = nullptr;
​
        while (root != nullptr) {
            if (root->left != nullptr) {
                // 寻找 predecessor：左子树的最右节点
                predecessor = root->left;
                //predecessor->right != root 确保不陷入循环（处理已建立的线索时）
                while (predecessor->right != nullptr && predecessor->right != root) {
                    predecessor = predecessor->right;
                }
                
                // 情况1：predecessor的右指针为空，建立线索
                //这一步相当于在中序遍历中标记 “遍历完左子树后应该回到 root”
                if (predecessor->right == nullptr) {
                    // 建立线索
                    predecessor->right = root;
                    // 继续遍历左子树 
                    root = root->left;
                }
                
                // 情况2：predecessor的右指针指向root，说明左子树已遍历完
                // 当再次遇到 predecessor->right == root 时，说明左子树已遍历完。
                else {
                    // 访问当前节点
                    res.push_back(root->val);
                    // 断开线索，恢复树结构
                    predecessor->right = nullptr;
                    // 转向右子树
                    root = root->right;
                }
            }
            
            // 如果没有左子树，直接访问当前节点并转向右子树
            else {
                res.push_back(root->val);
                root = root->right;
            }
        }
        return res;
    }
};

104. 二叉树的最大深度 简单

给定一个二叉树 root ，返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：3

示例 2：

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

提示：

• 树中节点的数量在 [0, 104] 区间内。

• -100 <= Node.val <= 100

//方法一：深度优先搜索
//如果我们知道了左子树和右子树的最大深度 l 和 r，那么该二叉树的最大深度即为max(l,r)+1
​
//时间复杂度：O(n)，其中 n 为二叉树节点的个数。每个节点在递归中只被遍历一次。
//空间复杂度：O(height)，其中 height 表示二叉树的高度。递归函数需要栈空间，而栈空间取决于递归的深度，因此空间复杂度等价于二叉树的高度。
​
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == nullptr) return 0;
        return max(maxDepth(root->left), maxDepth(root->right)) + 1;
    }
};

//方法二：广度优先搜索
//此时我们广度优先搜索的队列里存放的是「当前层的所有节点」。每次拓展下一层的时候，不同于广度优先搜索的每次只从队列里拿出一个节点，我们需要将队列里的所有节点都拿出来进行拓展，这样能保证每次拓展完的时候队列里存放的是当前层的所有节点，即我们是一层一层地进行拓展，最后我们用一个变量 ans 来维护拓展的次数，该二叉树的最大深度即为 ans。
​
//时间复杂度：O(n)，其中 n 为二叉树的节点个数。与方法一同样的分析，每个节点只会被访问一次。
//空间复杂度：此方法空间的消耗取决于队列存储的元素数量，其在最坏情况下会达到 O(n)。
​
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == nullptr) return 0;
        //队列初始化：使用队列 Q 存储待处理的节点，初始时队列中只有根节点。
        queue<TreeNode*> Q;
        Q.push(root);
        //深度计数器：ans 记录当前遍历的层数（初始为 0）。
        int ans = 0;
        //队列非空
        while (!Q.empty()) {
            //sz = Q.size() 表示当前层的节点总数。
            int sz = Q.size();
            //遍历当前层：
            while (sz > 0) {
                //取出队首节点 node，并将其左右子节点（若存在）加入队列。
                TreeNode* node = Q.front();
                // 将当前节点从队列中移除。
                Q.pop();
                if (node->left) Q.push(node->left);
                if (node->right) Q.push(node->right);
                //sz 递减，直到处理完当前层的所有节点
                sz -= 1;
            }
            //处理完一层后，ans 加 1，表示深度增加 1。
            ans += 1;
        } 
        return ans;
    }
};