emmm，本次就两题，因为我刷的那部分就五题树的。。
其实还是有点迷惑，我做完有个好习惯，去看那些运行速度比我快的代码。但是最近看到的都是，代码跟我写一样，速度怎么就有差那么多，最奇葩的一个是人家4ms,我就400ms，哎。
不牢骚了，切正题。
文章目录
题目（1）：二叉树的层序遍历
给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。
示例：
二叉树：[3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
返回其层次遍历结果：
[
[3],
[9,20],
[15,7]
]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
题目（2）：有序数组转化成平衡搜索二叉树
将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。
本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。
示例:
给定有序数组: [-10,-3,0,5,9],
一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树：
0
/ \
-3 9
/ /
-10 5
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
我的题解（1）（带图解释）
哎，好久不画图了，这题，中等题呢，虽然我是一遍过，所以我更要画一下图讲一下我的思路。
一目了然吧！
int maxDepth(TreeNode* root) {
if (root == NULL)
return 0;
return 1 + max(maxDepth(root->left), maxDepth(root->right));
}
void temp(vector<TreeNode*>& tree, vector<vector<int>>& ret, int tree_count, int ret_count) //将节点容器和返回值容器传入进行迭代
{
int sz = tree.size();
int push_flag = 0;
for (; tree_count < sz; tree_count++)
{
if (tree[tree_count]->left != NULL)
{
ret[ret_count].push_back(tree[tree_count]->left->val);
tree.push_back(tree[tree_count]->left);
push_flag = 1;
}
if (tree[tree_count]->right != NULL)
{
ret[ret_count].push_back(tree[tree_count]->right->val);
tree.push_back(tree[tree_count]->right);
push_flag = 1;
}
// tree_count++;
}
if (push_flag)
{
ret_count++;
temp(tree, ret, tree_count, ret_count);
}
}
vector<vector<int>> levelOrder(TreeNode* root)
{
int z = maxDepth(root);
vector<vector<int>> ret(z);
if (root == NULL)
return ret;
vector<TreeNode*> tree;
tree.push_back(root);
ret[0].push_back(root->val);
temp(tree,ret,0,1);
return ret;
}
因为要将数据取出来，所以长了些，需要先知道高度嘛。
我的题解（2）多种思路
看这个题啊，真是思绪万千，什么二分法啊、中序遍历啊都出来了，毕竟是有序嘛。
思路一：中序遍历
思路二：二分法
图我就不画了，如果快排不会的朋友可能理解起来就比较费劲了。那就去温习一下快排吧。
TreeNode* temp(vector<int>& nums, int start, int end)
{
if (start <= end)
{
int mid = (start + end) / 2;
TreeNode *root = new TreeNode(nums[mid]);
root->left = temp(nums, start, mid - 1);
root->right = temp(nums, mid + 1, end);
return root;
}
else
{
return NULL;
}
}
TreeNode* sortedArrayToBST(vector<int>& nums)
{
int sz = nums.size();
if (sz == 0)
return NULL;
return temp(nums,0,sz-1);
}
简单明了啊！
官方题解（1）
方法 1：递归
算法
最简单的解法就是递归，首先确认树非空，然后调用递归函数 helper(node, level)，参数是当前节点和节点的层次。程序过程如下：
输出列表称为 levels，当前最高层数就是列表的长度 len(levels)。比较访问节点所在的层次 level 和当前最高层次 len(levels) 的大小，如果前者更大就向 levels 添加一个空列表。
将当前节点插入到对应层的列表 levels[level] 中。
递归非空的孩子节点：helper(node.left / node.right, level + 1)。
作者：LeetCode
链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal/solution/er-cha-shu-de-ceng-ci-bian-li-by-leetcode/
来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
python写的
class Solution:
def levelOrder(self, root):
"""
:type root: TreeNode
:rtype: List[List[int]]
"""
levels = []
if not root:
return levels
def helper(node, level):
# start the current level
if len(levels) == level:
levels.append([])
# append the current node value
levels[level].append(node.val)
# process child nodes for the next level
if node.left:
helper(node.left, level + 1)
if node.right:
helper(node.right, level + 1)
helper(root, 0)
return levels
> 作者：LeetCode
> 链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal/solution/er-cha-shu-de-ceng-ci-bian-li-by-leetcode/
> 来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
官方题解（2）
方法一：中序遍历
class Solution:
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
def helper(left, right):
if left > right:
return None
# always choose left middle node as a root
p = (left + right) // 2
# inorder traversal: left -> node -> right
root = TreeNode(nums[p])
root.left = helper(left, p - 1)
root.right = helper(p + 1, right)
return root
return helper(0, len(nums) - 1)
> 作者：LeetCode
> 链接：https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree/solution/jiang-you-xu-shu-zu-zhuan-huan-wei-er-cha-sou-s-15/
> 来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
方法二：还是中序遍历
class Solution:
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
def helper(left, right):
if left > right:
return None
# always choose right middle node as a root
p = (left + right) // 2
if (left + right) % 2:
p += 1
# inorder traversal: left -> node -> right
root = TreeNode(nums[p])
root.left = helper(left, p - 1)
root.right = helper(p + 1, right)
return root
return helper(0, len(nums) - 1)
> 作者：LeetCode
> 链接：https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree/solution/jiang-you-xu-shu-zu-zhuan-huan-wei-er-cha-sou-s-15/
> 来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
方法三：依旧是，中序遍历
from random import randint
class Solution:
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
def helper(left, right):
if left > right:
return None
# choose random middle node as a root
p = (left + right) // 2
if (left + right) % 2:
p += randint(0, 1)
# inorder traversal: left -> node -> right
root = TreeNode(nums[p])
root.left = helper(left, p - 1)
root.right = helper(p + 1, right)
return root
return helper(0, len(nums) - 1)
> 作者：LeetCode
> 链接：https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree/solution/jiang-you-xu-shu-zu-zhuan-huan-wei-er-cha-sou-s-15/
> 来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
