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

https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree/description/?envType=study-plan-v2&envId=top-interview-150

这题考察的就是平衡二叉树的构建，所以需要掌握这部分的知识，如果对这方面知识有所欠缺的话可以看一下这篇博客：二叉搜索树/平衡二叉搜索树-CSDN博客

推销一下自己写的文章，我觉得我写的还是很详细的，认真看完的话这题就没什么问题了。

class Solution {
    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;
        }
    }
    public TreeNode sortedArrayToBST(int[] nums) {
        TreeNode root = null;
        for(int i = 0; i < nums.length; i++) {
            root = addNode(root, nums[i]);
        }
        return root;
    }

    //计算树的高度
    public int height(TreeNode node) {//叶节点的高度为1
        if(node == null) return 0;
        return Math.max(height(node.left), height(node.right)) + 1;
    }
    //计算平衡因子(左子树的高度 - 右子树的高度)
    public int balanceFactor(TreeNode node) {
        return height(node.left) - height(node.right);
    }

    //左旋
    public TreeNode leftRotate(TreeNode node) {
        TreeNode right = node.right;
        node.right = null; // 断开连接，不然会产生环
        if(right.left != null) node.right = right.left;
        right.left = node;
        return right;
    }
    //右旋
    public TreeNode rightRotate(TreeNode node) {
        TreeNode left = node.left;
        node.left = null; // 断开连接，不然会产生环
        if(left.right != null) node.left = left.right;
        left.right = node;
        return left;
    }

    //添加节点
    public TreeNode addNode(TreeNode node, int val) {
        if(node == null) {
            return new TreeNode(val);
        }
        if(val < node.val) node.left = addNode(node.left, val);
        else if(val > node.val) node.right = addNode(node.right, val);
        // 插入节点后检查是否需要平衡调整
        int balanceFactor = balanceFactor(node);
        if(balanceFactor > 1 && val < node.left.val) {//LL情况->右旋，node是被破坏节点，加入节点是破坏节点
            return rightRotate(node);
        }
        if(balanceFactor < -1 && val > node.right.val) {//RR情况->左旋
            return leftRotate(node);
        }
        if(balanceFactor > 1 && val > node.left.val) {//LR情况->被破坏节点的左节点左旋，被破坏节点右旋
            node.left = leftRotate(node.left);
            return rightRotate(node);
        }
        if(balanceFactor < -1 && val < node.right.val) {//RL情况->被破坏节点的右节点右旋，被破坏节点左旋
            node.right = rightRotate(node.right);
            return leftRotate(node);
        }
        return node;
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        int[] nums = {-10,-3,0,5,9};
        solution.sortedArrayToBST(nums);
    }
}