Binary Tree on Hang Zhang

Sum Root To Leaf Numbers

Tue, 21 Jan 2025 00:00:00 +0000

129. 求根节点到叶节点数字之和

分析

递归遍历二叉树：使用深度优先搜索遍历树，从根节点开始，到达每个叶节点时，记录下从根到当前节点的路径形成的数字
路径数字的累加：在遍历过程中，将当前节点的值添加到路径上，形成当前路径的数字。在到达叶节点时，将该数字加入总和
返回结果：最终返回计算得到的所有路径之和

时间复杂度

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(h)

C++代码

class Solution
{
public:
    int sumNumbers(TreeNode* root)
    {
        int res = 0;
        // 如果根节点非空，开始递归
        if (root)
            dfs(root, res, 0);
        return res;
    }

    void dfs(TreeNode* root, int& res, int cur)
    {
        // 将当前节点的值加到当前路径的数字中
        cur = cur * 10 + root->val;

        // 如果当前节点是叶节点，将路径数字加到结果中
        if (!root->left && !root->right)
            res += cur;

        // 继续递归遍历左子树
        if (root->left)
            dfs(root->left, res, cur);

        // 继续递归遍历右子树
        if (root->right)
            dfs(root->right, res, cur);
    }
};

Same Tree

Mon, 20 Jan 2025 00:00:00 +0000

100. 相同的树

分析

递归判断根节点：首先检查两个根节点 p 和 q 的值是否相等，如果它们相等，就继续递归地检查它们的左右子树
递归判断左右子树：分别递归比较 p 的左子树与 q 的左子树，p 的右子树与 q 的右子树
递归的终止条件：
- 如果两个节点都为空，说明它们相等
- 如果两个节点其中一个为空，或者它们的值不相等，返回 false
最终结果：只有当根节点和左右子树都完全相同的情况下，两棵树才是相同的

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(h)，h 是树的高度

C++代码

class Solution
{
public:
    bool isSameTree(TreeNode* p, TreeNode* q)
    {
        // 如果 p 和 q 都为空，说明它们是相同的
        if (!p && !q)
            return true;

        // 如果 p 和 q 其中一个为空，或它们的值不同，返回 false
        if (!p || !q || p->val != q->val)
            return false;

        // 递归地比较左右子树
        return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
    }
};

Delete Node In a BST

Thu, 02 Jan 2025 00:00:00 +0000

450. 删除二叉搜索树中的节点

分析

节点为叶子节点：
- 如果删除的节点没有子节点，直接将其置为 nullptr
节点只有一个子节点：如果删除的节点只有左子树或右子树，则将左子树或右子树上提
节点有两个子节点：
- 在这种情况下，删除节点无法直接处理。需要找到节点的后继节点（右子树中最小的节点）
- 找到右子树中的最小节点，将其值赋给当前删除节点，然后递归删除该后继节点（变为第二种情况）

时间复杂度

最坏情况下，树的高度为 O(h)，需要进行递归查找和删除节点操作，因此时间复杂度为 O(h)

对于平衡的二叉搜索树，时间复杂度为 O(log n)；对于退化为链表的情况，时间复杂度为 O(n)

空间复杂度

递归栈的空间复杂度为 O(h)，其中 h 是树的高度。对于平衡二叉搜索树，空间复杂度为 O(log n)；对于退化为链表的情况，空间复杂度为 O(n)

C++代码

class Solution {
public:

    // 主函数，调用删除逻辑并返回根节点
    TreeNode* deleteNode(TreeNode* root, int key)
    {
      del(root, key);  // 调用删除操作
      return root;     // 返回更新后的根节点
    }

    // 辅助函数：递归删除节点
    void del(TreeNode* &root, int key)
    {
      if (!root)  // 如果节点为空，直接返回
        return;

      // 根据 key 和当前节点值的大小关系决定递归方向
      if (root->val > key)
        del(root->left, key);  // 在左子树中查找
      else if (root->val < key)
        del(root->right, key); // 在右子树中查找
      else  // 找到目标节点
      {
        // 情况 1：节点没有子节点，直接删除
        if (!root->left && !root->right)
          root = nullptr;

        // 情况 2：节点只有右子树
        else if (!root->left)
          root = root->right;

        // 情况 3：节点只有左子树
        else if (!root->right)
          root = root->left;

        // 情况 4：节点有两个子树
        else
        {
          // 找右子树中最小的节点（后继节点）
          TreeNode* p = root->right;
          while (p->left)
            p = p->left;

          // 将后继节点的值赋给当前节点
          root->val = p->val;

          // 删除后继节点
          del(root->right, p->val);
        }
      }
    }
};

Longest Zigzag Path In a Binary Tree

Wed, 01 Jan 2025 00:00:00 +0000

1372. 二叉树中的最长交错路径

分析

路径的定义：
- 选择一个起始节点和方向：
  - 如果前进方向是右，则移动到右子节点
  - 如果前进方向是左，则移动到左子节点
- 每次移动后，改变方向继续前进
递归处理：
- 使用深度优先搜索（DFS）遍历整棵树
- 每次递归返回以：当前节点为起点的最长交错路径长度
方向参数：
- 每次递归调用带上方向参数 direction：
  - 0 表示上一次路径方向为左
  - 1 表示上一次路径方向为右
路径长度计算：
- 若当前节点移动方向为左，则当前路径长度为右子树返回值 + 1
- 若当前节点移动方向为右，则当前路径长度为左子树返回值 + 1
- 更新全局最大值 res

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(h)

C++代码

class Solution
{
public:
    int res = 0; // 全局变量记录最大交错路径长度

    int longestZigZag(TreeNode* root)
    {
        dfs(root, 0); // 从根节点开始递归，初始方向为左
        return res;
    }

    int dfs(TreeNode* root, int direction)
    {
        if (!root) // 空节点返回 0
            return 0;

        // 递归计算左右子树的交错路径
        int left = dfs(root->left, 0);  // 进入左子树，方向为左
        int right = dfs(root->right, 1); // 进入右子树，方向为右

        // 更新最长交错路径
        res = std::max(res, std::max(left, right));

        // 返回以当前节点为起点的路径长度
        if (direction == 0) // 当前方向为左
            return right + 1;
        return left + 1; // 当前方向为右
    }
};

Maximum Level Sum Of A Binary Tree

Wed, 01 Jan 2025 00:00:00 +0000

1161. 最大层内元素和

分析

层序遍历：
- 使用队列实现二叉树的层序遍历，从上到下逐层处理节点
- 每次处理完一层后，将当前层的所有子节点加入队列，供下一层处理
记录每层的总和：
- 对于每层的节点，计算该层所有节点值的总和
- 如果当前层的总和大于之前记录的最大总和，则更新最大总和，并记录当前层号
返回结果：
- 遍历完成后，返回总和最大的最小层号

时间复杂度

每个节点仅被访问一次，因此时间复杂度为 O(n)，其中 n 是二叉树的节点数

空间复杂度

队列中最多存储一层的节点数，在最坏情况下（完全二叉树），空间复杂度为 O(w)，其中 w 是二叉树的最大宽度

C++代码

class Solution
{
public:
    int maxLevelSum(TreeNode* root)
    {
      if (!root)
        return 0;
      std::queue<TreeNode*> q; // 队列用于层序遍历
      q.push(root);            // 将根节点入队
      int res = 0;             // 保存最大总和对应的层号
      int layer = 0;           // 当前层号
      int sum = INT_MIN;       // 初始化最大总和为最小整数

      while (q.size())         // 遍历队列直到为空
      {
        layer ++ ;             // 进入下一层，层号加 1
        int cur = 0;           // 当前层的总和
        int len = q.size();    // 当前层的节点数

        // 遍历当前层的所有节点
        while (len -- )
        {
          TreeNode* t = q.front();
          q.pop();
          if (t->left)         // 将左子节点加入队列
            q.push(t->left);
          if (t->right)        // 将右子节点加入队列
            q.push(t->right);
          cur += t->val;       // 累加当前节点的值
        }

        // 如果当前层的总和大于之前的最大总和，更新
        if (sum < cur)
        {
          sum = cur;           // 更新最大总和
          res = layer;         // 更新最大总和对应的层号
        }
      }

      return res;              // 返回层号
    }
};

Construct Binary Tree from Preorder and Inorder Traversal

Tue, 31 Dec 2024 00:00:00 +0000

105. 从前序与中序遍历序列构造二叉树

分析

用一个哈希表 pos 记录中序遍历中每个值的索引，方便快速查找
递归构造子树：
- 子树的根节点对应前序遍历的第一个节点
- 根据根节点在中序遍历中的位置，划分左右子树的前序和中序区间
- 分别递归构造左子树和右子树

时间复杂度

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    std::unordered_map<int, int> pos; // 中序遍历中值到索引的映射

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder)
    {
        // 建立中序遍历的值索引映射，方便快速定位根节点位置
        for (int i = 0; i < inorder.size(); ++i)
            pos[inorder[i]] = i;

        // 调用递归构造函数
        return build(preorder, inorder, 0, preorder.size() - 1, 0, inorder.size() - 1);
    }

    TreeNode* build(std::vector<int>& preorder, std::vector<int>& inorder, int pl, int pr, int il, int ir)
    {
        if (pl > pr) // 如果前序区间为空，返回空节点
            return nullptr;

        // 当前子树的根节点
        TreeNode* root = new TreeNode(preorder[pl]);

        // 根节点在中序遍历中的位置
        int k = pos[root->val];

        // 递归构造左子树
        root->left = build(preorder, inorder, pl + 1, pl + 1 + k - 1 - il, il, k - 1);

        // 递归构造右子树
        root->right = build(preorder, inorder, pl + 1 + k - 1 - il + 1, pr, k + 1, ir);

        return root;
    }
};

Flatten Binary Tree to Linked List

Tue, 31 Dec 2024 00:00:00 +0000

114. 二叉树展开为链表

分析

遍历二叉树的每个节点
如果当前节点存在左子树：
- 将左子树的最右节点找到，并连接到当前节点的右子树上
- 然后将当前节点的右子树替换为它的左子树，同时将左子树置为 null
移动到当前节点的右子节点，继续上述操作，直至遍历完所有节点

时间复杂度

时间复杂度 O(n)，每个节点遍历一次，且寻找左子树最右节点的过程也是线性的

空间复杂度

空间复杂度 O(1)

C++代码

class Solution
{
public:
    void flatten(TreeNode* root)
    {
        while (root) // 遍历每个节点
        {
            TreeNode* p = root->left; // 获取当前节点的左子树
            if (p) // 如果存在左子树
            {
                // 找到左子树的最右节点
                while (p->right)
                    p = p->right;

                // 将左子树的最右节点与右子树连接
                p->right = root->right;

                // 将当前节点的右子树替换为左子树
                root->right = root->left;

                // 将左子树置为 null
                root->left = nullptr;
            }
            // 移动到右子节点
            root = root->right;
        }
    }
};

Binary Tree Right Side View

Mon, 30 Dec 2024 00:00:00 +0000

199. 二叉树的右视图

分析

层序遍历二叉树：
- 使用队列（queue）进行二叉树的层序遍历
- 每次遍历一层节点时，将当前层的所有节点按顺序加入队列，同时将下一层的子节点也加入队列
记录右视图的节点值：
- 在遍历当前层时，记录当前层的最后一个节点的值，即为该层右侧视图中可见的节点
返回结果：
- 所有层的最后一个节点值构成二叉树的右视图

时间复杂度

时间复杂度：O(n)，其中 n 是二叉树中的节点数

空间复杂度

空间复杂度：O(w)，其中 w 是二叉树的最大宽度

C++代码

class Solution
{
public:
    vector<int> rightSideView(TreeNode* root)
    {
        std::vector<int> res; // 存储右视图节点值
        std::queue<TreeNode*> q; // 队列用于层序遍历

        if (!root) // 如果树为空，返回空结果
            return res;

        q.push(root); // 将根节点加入队列
        while (!q.empty())
        {
            int len = q.size(); // 当前层的节点数量
            while (len--)
            {
                TreeNode* temp = q.front(); // 获取当前层的节点
                q.pop();

                // 如果是当前层的最后一个节点，加入结果集
                if (len == 0)
                    res.push_back(temp->val);

                // 将左子节点加入队列
                if (temp->left)
                    q.push(temp->left);

                // 将右子节点加入队列
                if (temp->right)
                    q.push(temp->right);
            }
        }
        return res; // 返回右视图节点值
    }
};

Kth Smallest Element In A Bst

Mon, 30 Dec 2024 00:00:00 +0000

230. 二叉搜索树中第K小元素

分析

使用栈实现中序遍历
- 中序遍历按照「左 -> 根 -> 右」的顺序访问节点，因此可以使用显式栈来模拟递归
- 通过遍历左子树进入更小的节点，将节点依次压栈，直到左子树遍历完成
计数找到第 k 小的元素
- 每次弹出栈顶节点时，计数器 k 减一，直到 k = 0 时，当前节点即为第 k 小的节点
右子树遍历
- 在访问根节点后，转向右子树继续重复上述过程

时间复杂度

时间复杂度 O(h + k)，其中 h 是树的高度，k 是目标元素的位置。我们最多遍历 k 个节点，同时需要沿着树的高度走到叶节点

空间复杂度

空间复杂度：O(h)，栈的最大深度为树的高度

C++代码

class Solution
{
public:
    int kthSmallest(TreeNode* root, int k)
    {
        std::stack<TreeNode*> stk; // 显式栈用于模拟递归
        while (root || !stk.empty())
        {
            // 遍历左子树，将节点压栈
            while (root)
            {
                stk.push(root);
                root = root->left;
            }

            // 处理当前节点
            root = stk.top(); // 获取栈顶元素
            stk.pop();
            if (--k == 0) // 如果 k 减到 0，说明找到第 k 小的节点
                return root->val;

            // 转向右子树
            root = root->right;
        }

        return 0; // 理论上不会执行到这里，保证函数返回值
    }
};

Lowest Common Ancestor Of A Binary Tree

Mon, 30 Dec 2024 00:00:00 +0000

236. 二叉树的最近公共祖先

分析

使用递归深度优先搜索（DFS）
- 状态定义：
  - 如果某个子树中找到了 p ，则返回状态 1
  - 如果找到了 q ，则返回状态 2
  - 如果同时找到 p 和 q，状态为 3
- 递归逻辑：
  - 对当前节点的左右子树分别进行递归
  - 将左右子树的状态结果与当前节点的状态进行合并（按位或操作）
  - 如果当前节点的状态等于 3 且最近公共祖先 res 尚未被赋值，则更新 res
终止条件
- 当 p 和 q 在同一个子树中时，递归会找到它们最近的公共祖先并停止
- 如果两个节点在不同子树中，递归逻辑会找到分叉点，即最近公共祖先

时间复杂度

时间复杂度 O(n)，其中 n 是二叉树的节点总数，每个节点访问一次

空间复杂度

空间复杂度为 O(h)，其中 h 是二叉树的高度，递归调用栈的深度

C++代码

class Solution
{
public:
    TreeNode* res = nullptr; // 存储最近公共祖先节点

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q)
    {
        dfs(root, p, q); // 执行深度优先搜索
        return res; // 返回最近公共祖先
    }

    int dfs(TreeNode* root, TreeNode* p, TreeNode* q)
    {
        int state = 0; // 当前节点的状态
        if (!root)
            return state; // 如果当前节点为空，返回状态 0
        if (root == p)
            state |= 1; // 如果找到节点 p，更新状态为 1
        else if (root == q)
            state |= 2; // 如果找到节点 q，更新状态为 2

        // 递归左右子树
        state |= dfs(root->left, p, q);
        state |= dfs(root->right, p, q);

        // 如果当前状态为 3（即同时找到 p 和 q），且 res 尚未更新，更新 res
        if (state == 3 && !res)
            res = root;

        return state; // 返回当前节点的状态
    }
};

Binary Tree Maximum Path Sum

Sun, 29 Dec 2024 00:00:00 +0000

124. 二叉树中的最大路径和

分析

递归定义：
- 对于每个节点，我们通过递归计算以该节点为根的路径的最大贡献值（即该节点能为父节点提供的最大路径和）
贡献值的计算：
- 对于当前节点 root ：
  - 左子树提供的最大路径和 left = max(0, dfs(root->left))。取 0 是为了避免负贡献
  - 右子树提供的最大路径和 right = max(0, dfs(root->right))
更新全局最大路径和：
- 对于当前节点，路径和可能包含其左右子树的贡献值，因此计算路径和为：left + root->val + right
- 更新全局变量 res：res = max(res, left + root->val + right)
返回贡献值：
- 当前节点对父节点的最大贡献值为：root->val + max(left, right)，只取左右子树中的一个路径，避免形成环

时间复杂度

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(h)

C++代码

class Solution
{
public:
    int res = INT_MIN; // 全局变量，用于记录最大路径和

    int maxPathSum(TreeNode* root)
    {
        dfs(root); // 调用递归函数
        return res; // 返回最终结果
    }

    int dfs(TreeNode* root)
    {
        if (!root) // 如果当前节点为空，返回0
            return 0;

        // 递归计算左、右子树的最大贡献值，负值取0
        int left = std::max(0, dfs(root->left));
        int right = std::max(0, dfs(root->right));

        // 更新全局最大路径和
        res = std::max(res, left + root->val + right);

        // 返回当前节点对父节点的最大贡献值
        return root->val + std::max(left, right);
    }
};

Count Good Nodes In Binary Tree

Sun, 29 Dec 2024 00:00:00 +0000

1448. 统计二叉树中好节点

分析

递归遍历：
- 使用深度优先搜索 (DFS) 遍历树中所有节点
- 在遍历过程中，记录从根节点到当前节点路径上的最大值 max_val
判断当前节点是否为好节点：
- 如果当前节点的值大于或等于 max_val，说明该节点是好节点，计数器加一，并更新路径上的最大值为当前节点的值
继续递归左右子树：
- 对当前节点的左右子树递归调用，传递更新后的 max_val
累加结果：
- 将左子树和右子树的好节点数量加上当前节点的结果，返回总计数

时间复杂度

每个节点只访问一次，因此时间复杂度为 O(n)，其中 n 是树中节点的数量

空间复杂度

递归调用栈的空间复杂度为 O(h)，其中 h 是树的高度。在最坏情况下（单链树），空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int goodNodes(TreeNode* root)
    {
        // 从根节点开始深度优先搜索，初始路径的最大值为最小整数
        return dfs(root, INT_MIN);
    }

    int dfs(TreeNode* root, int max_val)
    {
        // 如果节点为空，返回0（没有好节点）
        if (!root)
            return 0;

        int res = 0;

        // 判断当前节点是否为好节点
        if (root->val >= max_val)
        {
            res = 1; // 当前节点是好节点
            max_val = root->val; // 更新路径上的最大值
        }

        // 递归左右子树并累加好节点数量
        return res + dfs(root->left, max_val) + dfs(root->right, max_val);
    }
};

Path Sum III

Sun, 29 Dec 2024 00:00:00 +0000

437. 路径总和III

分析

使用前缀和优化路径求和
- 前缀和定义：到当前节点的路径和（包括当前节点）
- 公式：假设当前路径的前缀和为 cur，目标和为 targetSum，那么我们需要寻找路径的前缀和 cur - targetSum
  - 若前缀和 cur - targetSum 存在，说明存在一条路径满足路径和等于 targetSum
具体步骤
- 使用哈希表 count 存储前缀和及其出现的次数：
  - count[0] = 1 初始化，表示路径和为 0 的路径有 1 条（即从根节点开始时）
- 深度优先搜索（DFS）遍历树的每个节点，维护当前路径的前缀和：
  - 更新当前节点的前缀和 cur
  - 检查是否存在路径满足 cur - targetSum
  - 将当前路径的前缀和存入哈希表
  - 递归遍历左右子树
  - 回溯时，删除当前节点对前缀和的贡献（将 count[cur]--）

时间复杂度

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(h)

C++代码

class Solution
{
public:
    std::unordered_map<long, int> count; // 哈希表存储前缀和及其出现次数
    int res = 0; // 记录满足条件的路径数

    int pathSum(TreeNode* root, int targetSum) {
        count[0] = 1; // 初始化路径和为 0 的路径有 1 条
        dfs(root, targetSum, 0); // 开始 DFS 遍历
        return res; // 返回结果
    }

    void dfs(TreeNode* root, int targetSum, long cur) {
        if (!root) return; // 如果当前节点为空，直接返回

        cur += root->val; // 更新当前路径和
        res += count[cur - targetSum]; // 检查是否存在前缀和满足条件
        count[cur]++; // 更新哈希表，记录当前路径和

        dfs(root->left, targetSum, cur); // 遍历左子树
        dfs(root->right, targetSum, cur); // 遍历右子树

        count[cur]--; // 回溯时移除当前节点对前缀和的贡献
    }
};

Leaf Similar Trees

Sat, 28 Dec 2024 00:00:00 +0000

872. 叶子相似的树

分析

深度优先搜索 (DFS)：
- 使用递归遍历二叉树
- 如果当前节点是叶子节点（没有左子节点和右子节点），将其值加入到结果序列中
- 如果不是叶子节点，则递归遍历其左子树和右子树
提取叶值序列：
- 对 root1 和 root2 分别进行深度优先搜索，提取两个叶值序列
比较序列：
- 判断两个序列是否相等，如果相等则返回 true，否则返回 false

时间复杂度

深度优先搜索：
- 对每棵树的所有节点遍历一次，时间复杂度为 O(n) ，其中 n 是节点数量
比较序列：
- 比较两个序列，时间复杂度为 O(min(n, m)) ，其中 n 和 m 分别为两棵树叶子节点的数量

总体时间复杂度为 O(n)

空间复杂度

递归调用栈：
- 在最坏情况下（树的深度为树的高度），递归调用栈需要 O(h) 的空间，其中 h 是树的高度
存储叶值序列：
- 每棵树的叶子节点最多为树节点总数的一半，存储序列的空间复杂度为 O(n)

总体空间复杂度为 O(n)

C++代码

class Solution
{
public:
    // 深度优先搜索，提取叶子节点的值
    void dfs(TreeNode* root, std::vector<int>& res)
    {
        // 如果当前节点为空，直接返回
        if (!root)
            return;

        // 如果当前节点是叶子节点，记录其值
        if (!root->left && !root->right)
            res.push_back(root->val);

        // 递归遍历左子树和右子树
        dfs(root->left, res);
        dfs(root->right, res);
    }

    bool leafSimilar(TreeNode* root1, TreeNode* root2)
    {
        // 分别存储两棵树的叶值序列
        std::vector<int> a, b;

        // 获取第一棵树的叶值序列
        dfs(root1, a);

        // 获取第二棵树的叶值序列
        dfs(root2, b);

        // 比较两棵树的叶值序列
        return a == b;
    }
};

Convert Sorted Array to Binary Search Tree

Mon, 02 Dec 2024 00:00:00 +0000

108. 将有序数组转换为二叉搜索树

分析

确定递归终止条件
- 如果当前范围内左边界 l 大于右边界 r，返回 nullptr，表示没有节点
递归构造子树
- 找到当前范围的中点 mid，该点的值作为当前子树的根节点
- 递归调用构建左子树，范围为 [l, mid - 1]
- 递归调用构建右子树，范围为 [mid + 1, r]
返回构造的根节点
- 根据中点值创建一个新的节点，连接左子树和右子树，返回该节点作为当前子树的根节点

时间复杂度

递归次数：每次递归划分数组为两半，总体复杂度为 O(logn) 层
每层处理复杂度：每层需要处理数组范围，整体为 O(n)

总时间复杂度 O(n)

空间复杂度

递归栈空间：递归深度为 O(logn)

C++代码

class Solution
{
public:
    TreeNode* sortedArrayToBST(vector<int>& nums)
    {
        // 调用递归函数构建平衡二叉搜索树
        return build(nums, 0, nums.size() - 1);
    }

    TreeNode* build(std::vector<int>& nums, int l, int r)
    {
        if (l > r) return nullptr; // 递归终止条件：无效范围
        int mid = (l + r) >> 1; // 找到当前范围的中点
        TreeNode* root = new TreeNode(nums[mid]); // 创建根节点
        root->left = build(nums, l, mid - 1); // 构建左子树
        root->right = build(nums, mid + 1, r); // 构建右子树
        return root; // 返回根节点
    }
};

Diameter of Binary Tree

Mon, 02 Dec 2024 00:00:00 +0000

543. 二叉树的直径

分析

主函数 diameterOfBinaryTree
- 初始化全局变量 res，用来存储最大直径
- 调用辅助函数 dfs，从根节点开始递归计算深度和路径长度
- 返回 res
辅助函数 dfs
- 基本情况：如果当前节点为空，返回深度为 0
- 递归计算左右子树深度：分别调用 dfs(root->left) 和 dfs(root->right)
- 更新直径：
  - 当前节点的路径长度为 left + right
  - 更新 res 为 max(res, left + right)
- 返回节点深度：节点的深度是其左右子树深度的最大值加 1

时间复杂度

时间复杂度 O(n)，其中 n 是节点总数，每个节点访问一次

空间复杂度

空间复杂度 O(h)，其中 h 是树的高度，递归栈的深度

C++代码

class Solution {
public:
    int res = 0; // 保存树的最大直径

    int diameterOfBinaryTree(TreeNode* root)
    {
        // 调用辅助函数计算直径
        dfs(root);
        return res;
    }

    int dfs(TreeNode* root)
    {
        // 如果节点为空，返回深度为 0
        if (!root) return 0;

        // 递归计算左右子树的深度
        int left = dfs(root->left);
        int right = dfs(root->right);

        // 更新最大直径：当前节点的左子树深度 + 右子树深度
        res = std::max(res, left + right);

        // 返回当前节点的深度
        return std::max(left, right) + 1;
    }
};

Invert Binary Tree

Mon, 02 Dec 2024 00:00:00 +0000

226. 翻转二叉树

分析

递归结束条件
- 如果当前节点 root 为 nullptr，直接返回 nullptr，表示已到达叶子节点的空子树
交换左右子树
- 使用 std::swap 交换当前节点的左子树和右子树
递归处理子树
- 对交换后的左子树调用 invertTree
- 对交换后的右子树调用 invertTree
返回结果
- 当所有节点都完成翻转后，返回根节点 root

时间复杂度

每个节点被访问一次，执行左右子树的交换操作，因此时间复杂度为 O(n)，其中 n 是节点总数

空间复杂度

递归调用的栈深度取决于树的高度。在最坏情况下（单链表形式的树），空间复杂度为 O(n)；在最优情况下（完全平衡二叉树），空间复杂度为 O(logn)

C++代码

// DFS
class Solution {
public:
    TreeNode* invertTree(TreeNode* root)
    {
        if (!root)
            return nullptr;  // 若节点为空，直接返回
        std::swap(root->left, root->right);  // 交换左右子树
        invertTree(root->left);  // 递归处理左子树
        invertTree(root->right);  // 递归处理右子树
        return root;  // 返回翻转后的树根节点
    }
};

// BFS
class Solution {
public:
    TreeNode* invertTree(TreeNode* root)
    {
        if (!root) return nullptr;

        std::queue<TreeNode*> q;
        q.push(root);  // 将根节点入队

        while (!q.empty()) {
            TreeNode* node = q.front();
            q.pop();

            // 交换左右子树
            std::swap(node->left, node->right);

            // 将子节点入队
            if (node->left) q.push(node->left);
            if (node->right) q.push(node->right);
        }

        return root;
    }
};

Is Symmetric

Mon, 02 Dec 2024 00:00:00 +0000

101. 对称二叉树

分析

主函数 isSymmetric
- 首先检查根节点是否为空。如果根节点为空，则树是对称的，返回 true
- 调用辅助函数 dfs，传入根节点的左右子树进行判断
辅助函数 dfs
- 判断当前两个节点：
  - 如果两者都为空，返回 true
  - 如果只有一个为空或节点值不同，返回 false
- 递归调用 dfs：
  - 比较左子树的左孩子和右子树的右孩子是否对称
  - 比较左子树的右孩子和右子树的左孩子是否对称

时间复杂度

时间复杂度 O(n)，n 为节点数，每个节点访问一次

空间复杂度

空间复杂度 O(h)，h 为树的高度，递归栈的深度

C++代码

class Solution
{
public:
    bool isSymmetric(TreeNode* root)
    {
        // 如果根节点为空，直接返回 true
        if (!root) return true;

        // 调用辅助函数判断左右子树是否对称
        return dfs(root->left, root->right);
    }

    bool dfs(TreeNode* left, TreeNode* right)
    {
        // 如果两个子树都为空，说明对称
        if (!left && !right) return true;

        // 如果只有一个子树为空，或两子树值不等，不对称
        if (!left || !right || left->val != right->val) return false;

        // 递归检查：左子树的左孩子和右子树的右孩子是否对称
        // 以及左子树的右孩子和右子树的左孩子是否对称
        return dfs(left->left, right->right) && dfs(left->right, right->left);
    }
};

Level Order

Mon, 02 Dec 2024 00:00:00 +0000

102. 二叉树的层序遍历

分析

初始化结果数组 res 和队列 q
若 root 为空，直接返回空的 res
将根节点加入队列，进入循环：
- 获取当前层节点数量 len
- 遍历当前层的所有节点：
  - 弹出队头节点，加入当前层结果数组 level
  - 将该节点的左右子节点（若存在）加入队列
- 将当前层的结果 level 加入到 res 中

时间复杂度

时间复杂度 O(n)，其中 n 是二叉树的节点总数。每个节点都会被访问一次

空间复杂度

空间复杂度 O(m)，其中 m 是二叉树的最大宽度。队列在最宽的层存储所有节点

C++代码

class Solution
{
public:
    vector<vector<int>> levelOrder(TreeNode* root)
    {
        // 存储最终结果
        std::vector<std::vector<int>> res;
        if (!root) return res; // 特殊情况：空树

        // 初始化队列
        std::queue<TreeNode*> q;
        q.push(root);

        // 遍历每一层
        while (!q.empty())
        {
            int len = q.size(); // 当前层节点数
            std::vector<int> level; // 存储当前层的节点值

            // 遍历当前层的节点
            while (len--)
            {
                TreeNode* node = q.front();
                q.pop();
                level.push_back(node->val); // 将节点值加入当前层结果
                if (node->left) q.push(node->left); // 加入左子节点
                if (node->right) q.push(node->right); // 加入右子节点
            }
            res.push_back(level); // 将当前层结果加入到最终结果
        }

        return res; // 返回层序遍历结果
    }
};

Binary Tree inorder Traversal

Sun, 01 Dec 2024 00:00:00 +0000

94. 二叉树的中序遍历

分析

中序遍历的顺序是：左子树 -> 根节点 -> 右子树

初始化数据结构
- 创建一个结果数组 res，用于存储中序遍历的结果
- 创建一个栈 stk，用于辅助遍历
模拟递归过程
- 向左下方向遍历：当前节点非空时，将当前节点压入栈，并将其移动到左子节点
- 回溯节点并访问右子树：如果当前节点为空（即到达左子树的最深处），从栈中弹出一个节点，访问该节点的值并存入结果数组，然后将当前节点移动到其右子节点
- 重复以上过程，直到栈为空且当前节点为空

时间复杂度

每个节点被访问两次（一次压入栈，一次弹出栈），因此时间复杂度为 O(n)，其中 n 是节点总数

空间复杂度

栈的深度取决于树的高度。在最坏情况下（如链状树），栈的空间复杂度为 O(n)；在平衡树中，栈的空间复杂度为 O(logn)

C++代码

// 非递归
class Solution
{
public:
    vector<int> inorderTraversal(TreeNode* root)
    {
        std::vector<int> res;          // 存储中序遍历结果
        std::stack<TreeNode*> stk;     // 辅助栈

        while (root || !stk.empty())   // 当节点非空或栈非空时，继续遍历
        {
            // 一直向左走，将路径上的节点压入栈
            while (root)
            {
                stk.push(root);        // 压入栈
                root = root->left;     // 移动到左子节点
            }

            // 回溯：弹出栈顶节点
            root = stk.top();
            stk.pop();

            res.push_back(root->val);  // 访问节点值

            root = root->right;        // 转向右子树
        }

        return res;                    // 返回结果
    }
};


// 递归
class Solution {
public:
    std::vector<int> res;

    void dfs(TreeNode* root)
    {
      if (!root) return;
      dfs(root->left);
      res.push_back(root->val);
      dfs(root->right);
    }

    vector<int> inorderTraversal(TreeNode* root)
    {
      dfs(root);
      return res;
    }
};

Maximum Depth of Binary Tree

Sun, 01 Dec 2024 00:00:00 +0000

104. 二叉树的最大深度

分析

初始化
- 创建一个变量 res，初始化为 0，用于记录树的最大深度
- 创建一个队列 q，用于辅助层序遍历
处理根节点
- 如果根节点 root 不为空，将其加入队列
层序遍历
- 每次从队列中取出当前层的所有节点（根据队列长度决定）
- 遍历当前层的节点，依次将每个节点的左右子节点加入队列
- 每处理完一层后，将深度变量 res 增加 1
返回结果
- 当队列为空时，树的所有层已遍历完，返回变量 res，即为最大深度

时间复杂度

每个节点被访问一次，因此时间复杂度为 O(n)，其中 n 是节点总数

空间复杂度

队列的最大空间取决于某一层的最大节点数。在完全二叉树的情况下，最大节点数可能是 n/2，因此空间复杂度为 O(n)

C++代码

// BFS
class Solution
{
public:
    int maxDepth(TreeNode* root)
    {
        int res = 0;  // 初始化深度为 0
        std::queue<TreeNode*> q;  // 辅助队列，用于层序遍历

        if (root)
            q.push(root);  // 如果根节点非空，加入队列

        while (!q.empty())  // 队列非空时，继续遍历
        {
            int len = q.size();  // 当前层的节点数量

            // 遍历当前层的所有节点
            while (len--)
            {
                TreeNode* node = q.front();  // 获取队首节点
                q.pop();  // 弹出队首节点

                // 将当前节点的左右子节点加入队列
                if (node->left)
                    q.push(node->left);
                if (node->right)
                    q.push(node->right);
            }
            ++res;  // 每完成一层，深度加 1
        }

        return res;  // 返回最大深度
    }
};

// DFS
class Solution
{
public:
    int maxDepth(TreeNode* root)
    {
      if (!root) return 0;
      return std::max(maxDepth(root->left), maxDepth(root->right)) + 1;
    }
};