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) 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。