【LeetCode 每日一题】1382. 将二叉搜索树变平衡——中序遍历 - 数组 - 平衡 BST

Problem: 1382. 将二叉搜索树变平衡

文章目录

  • [1. 整体思路](#1. 整体思路)
  • [2. 完整代码](#2. 完整代码)
  • [3. 时空复杂度](#3. 时空复杂度)
      • [时间复杂度: O ( N ) O(N) O(N)](#时间复杂度: O ( N ) O(N) O(N))
      • [空间复杂度: O ( N ) O(N) O(N)](#空间复杂度: O ( N ) O(N) O(N))

1. 整体思路

核心问题

我们需要将一棵可能高度不平衡 的二叉搜索树(BST),转换成一棵高度平衡的二叉搜索树。

算法逻辑

  1. 中序遍历 (In-order Traversal):

    • 二叉搜索树的特性 :通过中序遍历(左 -> 根 -> 右)可以得到一个升序的节点值序列。
    • 我们将原 BST 的所有节点值按照中序遍历的顺序存入一个 List<Integer> 中。
    • 这一步将树结构转化为了有序数组结构,消除了原本的树结构信息。
  2. 有序数组转平衡 BST (Reconstruction):

    • 这是一个经典问题(LeetCode 108. 将有序数组转换为二叉搜索树)。
    • 策略 :为了让生成的 BST 尽可能平衡,我们应该总是选择数组的中间元素作为根节点。
    • 这样,数组被均分为左右两半,左半部分构建左子树,右半部分构建右子树。
    • 这个过程递归进行,直到数组范围为空。
    • 由于每次都取中点,左右子树的高度差最多为 1,从而保证了结果是一棵高度平衡的 BST。

2. 完整代码

java 复制代码
import java.util.ArrayList;
import java.util.List;

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode balanceBST(TreeNode root) {
        // 1. 中序遍历获取升序数组
        List<Integer> nums = inorderTraversal(root);
        // 2. 将有序数组转换为平衡二叉搜索树
        return sortedArrayToBST(nums);
    }

    // 中序遍历辅助方法
    private List<Integer> inorderTraversal(TreeNode node) {
        List<Integer> ans = new ArrayList<>();
        dfs(ans, node);
        return ans;
    }

    // DFS 实现中序遍历
    private void dfs(List<Integer> ans, TreeNode node) {
        if (node == null) {
            return;
        }
        dfs(ans, node.left);
        ans.add(node.val);
        dfs(ans, node.right);
    }

    // 重建平衡 BST 入口
    private TreeNode sortedArrayToBST(List<Integer> nums) {
        // 这里的 range 是 [left, right) 左闭右开区间
        return buildBST(nums, 0, nums.size());
    }

    // 递归构建平衡 BST
    // left: 当前处理范围的起始索引 (inclusive)
    // right: 当前处理范围的结束索引 (exclusive)
    private TreeNode buildBST(List<Integer> nums, int left, int right) {
        // 递归终止条件:区间为空
        if (left == right) {
            return null;
        }
        
        // 取中间元素作为根节点
        // >>> 1 是无符号右移,相当于除以 2,但在处理负数时更安全(虽然这里索引是非负的)
        int m = (left + right) >>> 1;
        
        // 创建新节点,值为中间元素
        // 递归构建左子树:范围 [left, m)
        // 递归构建右子树:范围 [m + 1, right)
        return new TreeNode(nums.get(m), buildBST(nums, left, m), buildBST(nums, m + 1, right));
    }
}

3. 时空复杂度

假设二叉树的节点总数为 N N N。

时间复杂度: O ( N ) O(N) O(N)

  1. 中序遍历 :访问每个节点一次,耗时 O ( N ) O(N) O(N)。
  2. 重建 BST :
    • 构建过程本质上也是对每个节点访问一次(每次递归创建一个新节点)。
    • 总共有 N N N 个节点需要创建。
    • 虽然 buildBST 是递归调用的,但总的节点创建操作是线性的。
    • 耗时 O ( N ) O(N) O(N)。
  • 总计 : O ( N ) + O ( N ) = O ( N ) O(N) + O(N) = O(N) O(N)+O(N)=O(N)。

空间复杂度: O ( N ) O(N) O(N)

  1. 有序列表 nums :我们需要一个长度为 N N N 的 ArrayList 来存储节点值,空间 O ( N ) O(N) O(N)。
  2. 递归栈空间 :
    • 中序遍历时,最坏情况(斜树)栈深度为 N N N。
    • 重建 BST 时,树是平衡的,栈深度为 log ⁡ N \log N logN。
    • 取最大值,空间复杂度为 O ( N ) O(N) O(N)。
  • 结论 : O ( N ) O(N) O(N)。
相关推荐
ashiho10 小时前
【LeetCode hot 100】3. 无重复字符的最长子串 (三种解法)
java·数据结构·后端·算法·leetcode·滑动窗口
数据工匠老o10 小时前
数据库没死,业务卡住了:行锁等待、元数据锁、长事务的排查路径
数据库·算法·架构
黑客笔记11 小时前
安全态势感知中的资产失陷排名思考
人工智能·算法·网络安全
青少儿编程课堂13 小时前
蓝桥杯·全国青少年信息素养大赛·电子学会Python/C++考级:扫描线与线段树求矩形面积并解析
c++·python·算法·bfs·信息学竞赛
电科_银尘13 小时前
【大模型算法与工程 09】SGD、Momentum与AdamW:优化器如何选择
人工智能·算法
货拉拉技术15 小时前
视觉底座:货拉拉OCR的进阶之路
算法
__underline__15 小时前
冷门Python知识点005篇:list.sort( )的排序稳定性,是用0字节额外内存实现的
python·算法
风落青芜17 小时前
数据结构:堆的概念与实现
c语言·开发语言·数据结构·算法
Pniubi21 小时前
01背包类问题-力扣416.分割等和子集
算法·leetcode·职场和发展