leetcode-将二叉搜索树变平衡

 题目是LeetCode第180场周赛的第三题，链接：将二叉搜索树变平衡。具体描述为：给你一棵二叉搜索树，请你返回一棵平衡后的二叉搜索树，新生成的树应该与原来的树有着相同的节点值。如果一棵二叉搜索树中，每个节点的两棵子树高度差不超过 1 ，我们就称这棵二叉搜索树是平衡的 。如果有多种构造方法，请你返回任意一种。

• 树节点的数目在 1 到 10^4 之间。
• 树节点的值互不相同，且在 1 到 10^5 之间。

 示例:

输入：root = [1,null,2,null,3,null,4,null,null]
输出：[2,1,3,null,null,null,4]
解释：这不是唯一的正确答案，[3,1,4,null,2,null,null] 也是一个可行的构造方案。

 这是个medium难度的题目，做法相对也不难，只要知道先对节点排序（中序遍历即可），然后以排序后的中间节点为根节点，其左边的节点作为左子树，右边的节点作为右子树，然后这两个子树还是以同样的方式构建树即可。这样总能保证左右子树的节点数之差不超过1，进而可保证高度差不会超过1。

 时间复杂度为$O(n)$（其中n为节点数），空间复杂度为$O(n)$（存储排序后节点）。

 JAVA版代码如下：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    private List<Integer> sortedLst;
    
    private void inorderTraversal(TreeNode node) {
        if (node == null) {
            return;
        }
        inorderTraversal(node.left);
        sortedLst.add(node.val);
        inorderTraversal(node.right);
    }
    
    private TreeNode buildTree(int leftIdx, int rightIdx) {
        if (leftIdx > rightIdx) {
            return null;
        }
        if (leftIdx == rightIdx) {
            return new TreeNode(sortedLst.get(leftIdx));
        }
        int middleIdx = leftIdx + (rightIdx - leftIdx) / 2;
        TreeNode root = new TreeNode(sortedLst.get(middleIdx));
        root.left = buildTree(leftIdx, middleIdx - 1);
        root.right = buildTree(middleIdx + 1, rightIdx);
        return root;
    }
    
    public TreeNode balanceBST(TreeNode root) {
        sortedLst = new ArrayList<>();
        inorderTraversal(root);
        return buildTree(0, sortedLst.size() - 1);
    }
}

 提交结果如下:

 Python版代码如下：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def balanceBST(self, root: TreeNode) -> TreeNode:
        sortedLst = []
        def inorderTraversal(node):         #中序遍历，得到一个排好序的节点值列表
            if node is None:
                return
            inorderTraversal(node.left)
            sortedLst.append(node.val)
            inorderTraversal(node.right)

        def bulidTree(left, right):         #以列表中间节点为根节点，左边节点为左子树，右边节点为右子树
            if left > right:
                return None
            if left == right:
                return TreeNode(sortedLst[left])
            middldIdx = left + (right - left) // 2
            node = TreeNode(sortedLst[middldIdx])
            node.left = bulidTree(left, middldIdx - 1)
            node.right = bulidTree(middldIdx + 1, right)
            return node
        
        inorderTraversal(root)
        return bulidTree(0, len(sortedLst) - 1)

 提交结果如下: