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

news2025/1/11 0:36:27

题意理解：

我们需要根据一个数组来构建一个二叉搜索树，且该二叉搜索树也是高度平衡二叉树。

什么是高度平衡二叉树呢? 即对于每个节点来说，左右子树高度差不超过1

思路：我们总是从数组的中间位置作为根节点构建该树，这样就能保证左子树和右子树节点数目差值不超1。

解题方法：

递归迭代

1.递归

首先明确，我们总是先构造根节点，然后构造左子树，构造右子树。最终返回一棵完整的树。

如果输入的数组为nums长度为0，那么返回一个null。

额外补充一点，对于数组区间的判定经常会出错，可以先规定是左闭右开，还是左开右闭，然后严格按照约定来执行。

public TreeNode sortedArrayToBST(int[] nums) {
        if(nums.length==0) return null;
        int mid= Math.floorDiv(nums.length,2);
        TreeNode root=new TreeNode(nums[mid]);
        TreeNode left=sortedArrayToBST(Arrays.copyOfRange(nums,0,mid));
        TreeNode right=sortedArrayToBST(Arrays.copyOfRange(nums,mid+1,nums.length));
        root.left=left;
        root.right=right;
        return root;
    }



//方法二
public TreeNode sortedArrayToBST(int[] nums) {
        return sortedArrayToSubBST(nums,0,nums.length);
    }

    public TreeNode sortedArrayToSubBST(int[] nums,int left,int right) {
        if(left>=right) return null;
        if(right-left==1) return new TreeNode(nums[left]);
        int mid= left+Math.floorDiv((right-left),2);
        TreeNode root=new TreeNode(nums[mid]);
        TreeNode leftNode=sortedArrayToSubBST(nums,left,mid);
        TreeNode rightNode=sortedArrayToSubBST(nums,mid+1,right);
        root.left=leftNode;
        root.right=rightNode;
        return root;
    }

2.迭代

迭代法的话，需要进行分析。

为了实现迭代，我们需要三个来进行维护，一个用来维护当前新建节点，一个用来数组左子树下标，另一个用来维护右子树下标。

public TreeNode sortedArrayToBST2(int[] nums) {
        Queue<TreeNode> nodes=new LinkedList<>();
        Queue<Integer> leftIndex=new LinkedList<>();
        Queue<Integer> rightIndex=new LinkedList<>();
        //初始化
        TreeNode root=new TreeNode();
        nodes.offer(root);
        leftIndex.offer(0);
        rightIndex.offer(nums.length-1);
        //为了实现迭代使用三个数组
        while(!nodes.isEmpty()){
            //创建根节点
            TreeNode curNode=nodes.poll();
            int left=leftIndex.poll();
            int right=rightIndex.poll();
            int mid=Math.floorDiv((left+right),2);
            curNode.val=nums[mid];

            //处理左区间
            if(left<=mid-1){
                curNode.left=new TreeNode();
                nodes.offer(curNode.left);
                leftIndex.offer(left);
                rightIndex.offer(mid-1);
            }

            //处理右区间
            if(right>=mid+1){
                curNode.right=new TreeNode();
                nodes.offer(curNode.right);
                leftIndex.offer(mid+1);
                rightIndex.offer(right);
            }
        }

        return root;
    }