难度简单713
给你一个整数数组 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 按 严格递增 顺序排列
package Solution108;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
class Solution {
public TreeNode sortedArrayToBST(int[] nums) {
int n = nums.length;
TreeNode root = sortedArrayToBST(nums, 0, n - 1);
return root;
}
TreeNode sortedArrayToBST(int arr[], int start, int end) {
// System.out.println(Arrays.toString(arr));
/* Base Case */
if (start > end) {
return null;
}
/* Get the middle element and make it root */
int mid = (start + end) / 2;
TreeNode node = new TreeNode(arr[mid]);
/*
* Recursively construct the left subtree and make it left child of root
*/
node.left = sortedArrayToBST(arr, start, mid - 1);
/*
* Recursively construct the right subtree and make it right child of root
*/
node.right = sortedArrayToBST(arr, mid + 1, end);
return node;
}
public List<List<Integer>> levelOrderBottom(TreeNode root) {
LinkedList<List<Integer>> result = new LinkedList<>();
if (root == null)
return result;
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
while (!queue.isEmpty()) {
List<Integer> oneLevel = new ArrayList<>();
// 每次都取出一层的所有数据
int count = queue.size();
for (int i = 0; i < count; i++) {
TreeNode node = queue.poll();
oneLevel.add(node.val);
if (node.left != null)
queue.add(node.left);
if (node.right != null)
queue.add(node.right);
}
// 每次都往队头塞
result.addFirst(oneLevel);
}
return result;
}
public static List<List<Integer>> levelOrder(TreeNode root) {
if (root == null) {
return Collections.emptyList();
}
Queue<TreeNode> queue = new LinkedList<TreeNode>();
queue.add(root);
int count = 1;
List<List<Integer>> finalList = new ArrayList<List<Integer>>();
while (count != 0) {
List<Integer> list = new ArrayList<Integer>();
Queue<TreeNode> nextQueue = new LinkedList<TreeNode>();
while (!queue.isEmpty()) {
TreeNode node = queue.poll();
list.add(node.val);
count--;
if (node.left != null) {
nextQueue.add(node.left);
}
if (node.right != null) {
nextQueue.add(node.right);
}
}
finalList.add(list);
count = nextQueue.size();
queue = nextQueue;
}
return finalList;
}
public static void main(String[] args) {
Solution sol = new Solution();
int[] nums = { -10, -3, 0, 5, 9 };
System.out.println(levelOrder(sol.sortedArrayToBST(nums)));
}
}