0108-有序数组转为二叉搜索树

给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。

高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

示例 1：

输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]
解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：

示例 2：

输入：nums = [1,3]
输出：[3,1]
解释：[1,3] 和 [3,1] 都是高度平衡二叉搜索树。

提示：

1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 按 严格递增 顺序排列

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree

参考：

• https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree/solution/dai-ma-sui-xiang-lu-dai-ni-xue-tou-er-ch-9876/

python

# 0108.将有序数组构造为二叉搜索树
 
class Solution1:
    def sortedArrayToBST(self, nums: [int]) -> TreeNode:
        """
        递归-左闭右开
        :param nums:
        :return:
        """
        def sortedToBST(nums: [int], left: int, right: int) -> TreeNode:
            if left >= right:
                return None
            if right - left == 1:
                return TreeNode(nums[left])
 
            # 若为偶数，取的为中间两值的左值
            mid = left + int((right-left)/2)
 
            root = TreeNode(nums[mid])
            # [left, mid)
            root.left = sortedToBST(nums, left, mid)
            # [mid+1, right)
            root.right = sortedToBST(nums, mid+1, right)
            return root
 
        return sortedToBST(nums, 0, len(nums))
 
class Solution2:
    def sortedArrayToBST(self, nums: [int]) -> TreeNode:
        """
        递归-左闭右闭
        :param nums:
        :return:
        """
        def sortedToBST(nums: [int], left: int, right: int) -> TreeNode:
            if left > right:
                return None
 
            mid = left + int((right-left)/2)
            root = TreeNode(nums[mid])
            root.left = sortedToBST(nums, left, mid-1)
            root.right = sortedToBST(nums, mid+1, right)
            return root
 
        return sortedToBST(nums, 0, len(nums)-1)
 
class Solution3:
    def sortedArrayToBST(self, nums: [int]) -> TreeNode:
        """
        迭代-左闭右闭-LC超时
        :param nums:
        :return:
        """
        if len(nums) == 0:
            return None
 
        # root initial
        root = TreeNode(-1)
        # 维护三个队列，节点队列，左部节点下标队列，右部节点下标队列
        nodeQueue = []
        leftQueue = []
        rightQueue = []
 
        # 根节点入队
        nodeQueue.append(root)
        # 下标队列入队
        leftQueue.append(0)
        rightQueue.append(len(nums)-1)
 
        while nodeQueue:
            curNode = nodeQueue.pop(0)
            left = leftQueue.pop(0)
            right = rightQueue.pop(0)
            mid = left + int((right-left)>>1)
 
            # 中间节点
            curNode.val = nums[mid]
 
            # 左区间构造二叉树
            if left <= mid -1:
                curNode.left = TreeNode(-1)
                nodeQueue.append(curNode.left)
                leftQueue.append(left)
                rightQueue.append(mid-1)
            # 右区间构造二叉树
            if right >= mid -1:
                curNode.right = TreeNode(-1)
                nodeQueue.append(curNode.right)
                leftQueue.append(mid+1)
                rightQueue.append(right)
 
        return root
 
 
 

golang

package binaryTree
 
import "container/list"
 
func sortedArrayToBST(nums []int) *TreeNode {
	// 递归-左闭右开
	if len(nums)==0{return nil}//终止条件，最后数组为空则可以返回
	root:=&TreeNode{nums[len(nums)/2],nil,nil}//按照BSL的特点，从中间构造节点
	root.Left=sortedArrayToBST(nums[:len(nums)/2])//数组的左边为左子树
	root.Right=sortedArrayToBST(nums[len(nums)/2+1:])//数字的右边为右子树
	return root
}
 
func sortedArrayToBST2(nums []int) *TreeNode {
	// 递归-左闭右闭
	var sortedToBST func(nums []int, left int, right int) *TreeNode
	sortedToBST = func(nums []int, left int, right int) *TreeNode {
		if left > right {
			return nil
		}
		var mid int = left + (right-left) >> 1
		root := &TreeNode{Val: nums[mid]}
		root.Left = sortedToBST(nums, left, mid-1)
		root.Right = sortedToBST(nums, mid+1, right)
		return root
	}
	return sortedToBST(nums, 0, len(nums)-1)
}
 
func sortedArrayToBST3(nums []int) *TreeNode {
	// 迭代-左闭右闭-LC超时
	if len(nums) == 0 {
		return nil
	}
	// 根节点初始化
	root := &TreeNode{Val: -1}
	// 维护三个队列，节点队列，左区间下标队列，右区间下标队列
	nodeQueue := list.New()
	leftQueue := []int{}
	rightQueue := []int{}
 
	// 节点&下标入队
	nodeQueue.PushBack(root)
	leftQueue = append(leftQueue,0)
	rightQueue = append(rightQueue,len(nums)-1)
 
	// 构造二叉搜索树
	for nodeQueue.Len() > 0 {
		// 出队
		curNode := nodeQueue.Remove(nodeQueue.Front()).(*TreeNode)
		left := leftQueue[0]
		if len(leftQueue) == 1{
			leftQueue = []int{}
		} else {
			leftQueue = leftQueue[1:]
		}
		right := rightQueue[0]
		if len(rightQueue) == 1{
			rightQueue = []int{}
		} else {
			rightQueue = rightQueue[1:]
		}
		var mid int = left + (right-left) >> 1
		// 中间节点
		curNode.Val = nums[mid]
		// 左右区间构造二叉树
		if left <= mid -1 {
			curNode.Left = &TreeNode{Val: -1}
			nodeQueue.PushBack(curNode.Left)
			leftQueue = append(leftQueue, left)
			rightQueue = append(rightQueue, mid-1)
		}
		if right >= mid -1 {
			curNode.Right = &TreeNode{Val: -1}
			nodeQueue.PushBack(curNode.Right)
			leftQueue = append(leftQueue, mid+1)
			rightQueue = append(rightQueue, right)
		}
 
 
	}
	return root
}