leetcode 108. Convert Sorted Array to Binary Search Tree-数组转搜索树|递归|非递归

最新推荐文章于 2024-09-19 06:01:52 发布

Code_Granker

最新推荐文章于 2024-09-19 06:01:52 发布

阅读量1.5k

点赞数 1

分类专栏： LeetCode 文章标签： Java Python leetcode

本文链接：https://blog.csdn.net/happyaaaaaaaaaaa/article/details/51496939

版权

LeetCode 专栏收录该内容

167 篇文章 0 订阅

订阅专栏

原题链接：108. Convert Sorted Array to Binary Search Tree

【思路-Java、Python】-递归实现

首先要明白二叉搜索树的性质——任意一个节点的值都不小于它的左子树上任一节点的值，任意一个节点的值不大于它的右子树上任一节点的值。高度平衡的二叉搜索数，要求平衡因子不大于1。

题目给定一个已经排好序的数组，要求构造一个高度平衡的二叉搜索树。那么，我们可以采用递归方式进行处理

1. 先得到数组元素的中间元素，将它的值作为根节点

2. 并且以它为中间中介，将数组划分为左右区间。根节点的左子树指向左区间，右节点指向右区间。

3. 再针对左右区间进行同样的操作。直到左指针和右指针重合。

public class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        return dfs(nums, 0, nums.length-1);
    }
    public TreeNode dfs(int[] nums, int left, int right) {
        if(left > right) return null;
        int mid = (left+right) / 2;
        TreeNode root = new TreeNode(nums[mid]);
        root.left = dfs(nums, left, mid-1);
        root.right = dfs(nums, mid+1, right);
        return root;
    }
}

32 / 32 test cases passed. Runtime: 1 ms Your runtime beats 7.24% of javasubmissions.

class Solution(object):
    def sortedArrayToBST(self, nums):
        """
        :type nums: List[int]
        :rtype: TreeNode
        """
        def dfs(nums,left,right) :
            if left <= right :
                mid = (left+right) / 2
                root = TreeNode(nums[mid])
                root.left = dfs(nums,left,mid-1)
                root.right = dfs(nums,mid+1,right)
                return root
        return dfs(nums,0,len(nums)-1)

32 / 32 test cases passed. Runtime: 108 ms Your runtime beats 23.81% of pythonsubmissions.

【思路2-Java】-非递归实现

可能有些读者想了解非递归方式是怎么实现的。这里我对递归实现做一个补充。

我们需要2个栈，一个栈用于存放区间的左、右边界指针——left、right，还需要一个栈存放当前子区间对应子树的根节点。相比递归实现，增加了很多变量的压栈、出栈操作，耗费时间也增加了不少：

public class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        if (nums == null || nums.length == 0) return null;
        Stack<Integer> stack = new Stack<Integer>();
        Stack<TreeNode> tree = new Stack<TreeNode>();
        stack.add(nums.length - 1);
        stack.add(0);
        TreeNode root = new TreeNode(0);
        tree.add(root);
        
        while(!stack.isEmpty()) {
            int left = stack.pop();
            int right = stack.pop();
            int mid = left + (right-left) / 2;
            TreeNode node = tree.pop();
            node.val = nums[mid];
            int r = mid - 1, l = left;
            if (l <= r) {
                node.left = new TreeNode(0);
                tree.add(node.left);
                stack.push(r);
                stack.push(l);
            }
            l = mid + 1;
            r = right;
            if (l <= r) {
                node.right = new TreeNode(0);
                tree.add(node.right);
                stack.push(r);
                stack.add(l);
            }
        }
        return root;
    }

32 / 32 test cases passed. Runtime: 11 ms Your runtime beats 0.95% of javasubmissions.