给你一个整数数组 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
参考：
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
}