标签：1807 right return val Review 155 root self left
文章目录
70 · 二叉树的层次遍历 II
给出一棵二叉树，返回其节点值从底向上的层次序遍历（按从叶节点所在层到根节点所在的层遍历，然后逐层从左往右遍历）
bfs可以做到bugfree了。
from typing import (
List,
)
from lintcode import (
TreeNode,
)
"""
Definition of TreeNode:
class TreeNode:
def __init__(self, val):
self.val = val
self.left, self.right = None, None
"""
from collections import deque
class Solution:
"""
@param root: A tree
@return: buttom-up level order a list of lists of integer
"""
def level_order_bottom(self, root: TreeNode) -> List[List[int]]:
# write your code here
if not root:
return []
que = deque([root])
tmp = []
while que:
li = []
for _ in range(len(que)):
node = que.popleft()
li.append(node.val)
if node.left:
que.append(node.left)
if node.right:
que.append(node.right)
tmp.append(li)
return tmp[::-1]
1807 · 斐波纳契数列简单
描述
查找斐波纳契数列中第 N 个数。
所谓的斐波纳契数列是指：
前2个数是 0 和 1 。
第 i 个数是第 i-1 个数和第i-2 个数的和。
斐波纳契数列的前10个数字是：
0, 1, 1, 2, 3, 5, 8, 13, 21, 34 …
递归版：
def fibonacci(self, n: int) -> int:
# write your code here
if n == 1 or n == 2:
return n - 1
return self.fibonacci(n - 1) + self.fibonacci(n - 2)
非递归版：
def fibonacci(self, n: int) -> int:
# write your code here
a, b = 0, 1
for _ in range(2, n):
a, b = b, a + b
return b
242 · 将二叉树按照层级转化为链表
给一棵二叉树，设计一个算法为每一层的节点建立一个链表。也就是说，如果一棵二叉树有 D 层，那么你需要创建 D 条链表。
"""
Definition of TreeNode:
class TreeNode:
def __init__(self, val):
this.val = val
this.left, this.right = None, None
Definition for singly-linked list.
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
"""
from collections import deque
class Solution:
# @param {TreeNode} root the root of binary tree
# @return {ListNode[]} a lists of linked list
def binaryTreeToLists(self, root):
# Write your code here
if not root: return []
que = deque([root])
res = []
while que:
dummy = ListNode(-1)
head = dummy
for _ in range(len(que)):
node = que.popleft()
head.next = ListNode(node.val)
head = head.next
if node.left:
que.append(node.left)
if node.right:
que.append(node.right)
res.append(dummy.next)
return res
95 · 验证二叉查找树
给定一个二叉树，判断它是否是合法的二叉查找树(BST)
一棵BST定义为：
节点的左子树中的值要严格小于该节点的值。
节点的右子树中的值要严格大于该节点的值。
左右子树也必须是二叉查找树。
一个节点的树也是二叉查找树。
没写出来，没保证左边值都比隔层小。
from lintcode import (
TreeNode,
)
"""
Definition of TreeNode:
class TreeNode:
def __init__(self, val):
self.val = val
self.left, self.right = None, None
"""
class Solution:
"""
@param root: The root of binary tree.
@return: True if the binary tree is BST, or false
"""
def is_valid_b_s_t(self, root: TreeNode) -> bool:
# write your code here
if not root:
return True
elif not root.left and not root.right:
return True
bool1, bool2 = True, True
if root.left:
if root.left.val >= root.val:
return False
bool1 = self.is_valid_b_s_t(root.left)
if root.right:
if root.right.val <= root.val:
return False
bool2 = self.is_valid_b_s_t(root.right)
return bool1 and bool2
想起来之前怎么做的了，是老师讲的方法，把它们遍历一遍，看是不是升序。
def isValidBST(self, root):
# write your code here
res = []
self.BST_traverse(root, res)
for i in range(1, len(res)):
if res[i] <= res[i - 1]:
return False
return True
def BST_traverse(self, root, res):
if not root: return
self.BST_traverse(root.left, res)
res.append(root.val)
self.BST_traverse(root.right, res)
155 · 二叉树的最小深度
给定一个二叉树，找出其最小深度。
二叉树的最小深度为根节点到最近叶子节点的最短路径上的节点数量。
BFS版本：
from lintcode import (
TreeNode,
)
"""
Definition of TreeNode:
class TreeNode:
def __init__(self, val):
self.val = val
self.left, self.right = None, None
"""
from collections import deque
class Solution:
"""
@param root: The root of binary tree
@return: An integer
"""
def min_depth(self, root: TreeNode) -> int:
# write your code here
if not root:
return 0
que = deque([root])
depth = 1
while que:
for _ in range(len(que)):
node = que.popleft()
if not node.left and not node.right:
return depth
if node.left:
que.append(node.left)
if node.right:
que.append(node.right)
depth += 1
DFS版本：
from lintcode import (
TreeNode,
)
"""
Definition of TreeNode:
class TreeNode:
def __init__(self, val):
self.val = val
self.left, self.right = None, None
"""
class Solution:
"""
@param root: The root of binary tree
@return: An integer
"""
def min_depth(self, root: TreeNode) -> int:
# write your code here
if not root:
return 0
depth = 1
dep = self.dfs(root, depth)
return dep
def dfs(self, root, depth):
if not root.left and not root.right:
return depth
left_dep, right_dep = float('inf'), float('inf')
if root.left:
left_dep = self.dfs(root.left, depth + 1)
if root.right:
right_dep = self.dfs(root.right, depth + 1)
return min(left_dep, right_dep)
下面是官方答案，我感觉我想不到
def minDepth(self, root):
if root is None:
return 0
leftDepth = self.minDepth(root.left)
rightDepth = self.minDepth(root.right)
# 当左子树或右子树为空时，最小深度取决于另一颗子树
if leftDepth == 0 or rightDepth == 0:
return leftDepth + rightDepth + 1
return min(leftDepth, rightDepth) + 1
标签：1807,right,return,val,Review,155,root,self,left 来源： https://blog.csdn.net/weixin_43716712/article/details/123228758
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。