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） 著作權歸作者所有。商業轉載請聯繫作者獲得授權，非商業轉載請註明出處。