難度簡單60
請考慮一顆二叉樹上所有的葉子，這些葉子的值按從左到右的順序排列形成一個 葉值序列 。
舉個例子，如上圖所示，給定一顆葉值序列爲 (6, 7, 4, 9, 8) 的樹。
如果有兩顆二叉樹的葉值序列是相同，那麼我們就認爲它們是 葉相似 的。
如果給定的兩個頭結點分別爲 root1 和 root2 的樹是葉相似的，則返回 true；否則返回 false 。
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def leafSimilar(self, root1: TreeNode, root2: TreeNode) -> bool:
num1=[]
num2=[]
def leaf(root,nums):
if root and not root.left and not root.right:
nums.append(root.val)
if root.left:
leaf(root.left,nums)
if root.right:
leaf(root.right,nums)
return nums
return leaf(root1,num1) == leaf(root2,num2)
難度簡單410
給定兩個二叉樹，想象當你將它們中的一個覆蓋到另一個上時，兩個二叉樹的一些節點便會重疊。
你需要將他們合併爲一個新的二叉樹。合併的規則是如果兩個節點重疊，那麼將他們的值相加作爲節點合併後的新值，否則不爲 NULL 的節點將直接作爲新二叉樹的節點。
示例 1:
輸入:
Tree 1 Tree 2
1 2
/ \ / \
3 2 1 3
/ \ \
5 4 7
輸出:
合併後的樹:
3
/ \
4 5
/ \ \
5 4 7
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def mergeTrees(self, t1: TreeNode, t2: TreeNode) -> TreeNode:
if t1 is None:
return t2
if t2 is None:
return t1
root = TreeNode(t1.val+t2.val)
root.left=self.mergeTrees(t1.left,t2.left)
root.right=self.mergeTrees(t1.right,t2.right)
return root
難度簡單35
給定一個有序整數數組，元素各不相同且按升序排列，編寫一個算法，創建一棵高度最小的二叉搜索樹。
示例:
給定有序數組: [-10,-3,0,5,9],
一個可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面這個高度平衡二叉搜索樹：
0
/ \
-3 9
/ /
-10 5
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
if not nums:
return
mid = len(nums)//2
root = TreeNode(nums[mid])
root.left = self.sortedArrayToBST(nums[:mid])
root.right = self.sortedArrayToBST(nums[mid+1:])
return root
難度簡單49
如果二叉樹每個節點都具有相同的值，那麼該二叉樹就是單值二叉樹。
只有給定的樹是單值二叉樹時，才返回 true；否則返回 false。
示例 1：
輸入：[1,1,1,1,1,null,1] 輸出：true
示例 2：
輸入：[2,2,2,5,2] 輸出：false
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def isUnivalTree(self, root: TreeNode) -> bool:
vals=[]
def dfs(node):
if node:
vals.append(node.val)
dfs(node.left)
dfs(node.right)
dfs(root)
return len(set(vals))==1
難度簡單37
給定一棵二叉搜索樹，請找出其中第k大的節點。
示例 1:
輸入: root = [3,1,4,null,2], k = 1 3 / \ 1 4 \ 2 輸出: 4
示例 2:
輸入: root = [5,3,6,2,4,null,null,1], k = 3
5
/ \
3 6
/ \
2 4
/
1
輸出: 4
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def kthLargest(self, root: TreeNode, k: int) -> int:
def dfs(root):
if not root:
return
dfs(root.right)
if self.k == 0:
return
self.k-=1
if self.k == 0:
self.res=root.val
dfs(root.left)
self.k = k
dfs(root)
return self.res
難度簡單76
在二叉樹中，根節點位於深度 0 處，每個深度爲 k 的節點的子節點位於深度 k+1 處。
如果二叉樹的兩個節點深度相同，但父節點不同，則它們是一對堂兄弟節點。
我們給出了具有唯一值的二叉樹的根節點 root，以及樹中兩個不同節點的值 x 和 y。
只有與值 x 和 y 對應的節點是堂兄弟節點時，才返回 true。否則，返回 false。
示例 1：
輸入：root = [1,2,3,4], x = 4, y = 3 輸出：false
示例 2：
輸入：root = [1,2,3,null,4,null,5], x = 5, y = 4 輸出：true
示例 3：
輸入：root = [1,2,3,null,4], x = 2, y = 3 輸出：false
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def isCousins(self, root: TreeNode, x: int, y: int) -> bool:
parent ={}
depth ={}
def dfs(node,par=None):
if node:
if par:
depth[node.val]=1+depth[par.val]
else:
depth[node.val] = 0
parent[node.val] = par
dfs(node.left,node)
dfs(node.right,node)
dfs(root)
return depth[x] == depth[y] and parent[x]!=parent[y]
難度簡單236
給定一個二叉搜索樹，同時給定最小邊界L 和最大邊界 R。通過修剪二叉搜索樹，使得所有節點的值在[L, R]中 (R>=L) 。你可能需要改變樹的根節點，所以結果應當返回修剪好的二叉搜索樹的新的根節點。
示例 1:
輸入:
1
/ \
0 2
L = 1
R = 2
輸出:
1
\
2
示例 2:
輸入:
3
/ \
0 4
\
2
/
1
L = 1
R = 3
輸出:
3
/
2
/
1
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def trimBST(self, root: TreeNode, L: int, R: int) -> TreeNode:
def trim(node):
if not node:
return None
elif node.val>R:
return trim(node.left)
elif node.val<L:
return trim(node.right)
else:
node.left = trim(node.left)
node.right = trim(node.right)
return node
return trim(root)
難度簡單505
將一個按照升序排列的有序數組，轉換爲一棵高度平衡二叉搜索樹。
本題中，一個高度平衡二叉樹是指一個二叉樹每個節點 的左右兩個子樹的高度差的絕對值不超過 1。
示例:
給定有序數組: [-10,-3,0,5,9],
一個可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面這個高度平衡二叉搜索樹：
0
/ \
-3 9
/ /
-10 5
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
def helper(left,right):
if left>right:
return None
p = (left+right)//2
root = TreeNode(nums[p])
root.left = helper(left,p-1)
root.right = helper(p+1,right)
return root
return helper(0,len(nums)-1)
難度簡單96
給定一個 N 叉樹，找到其最大深度。
最大深度是指從根節點到最遠葉子節點的最長路徑上的節點總數。
例如，給定一個 3叉樹 :
我們應返回其最大深度，3。
"""
# Definition for a Node.
class Node:
def __init__(self, val=None, children=None):
self.val = val
self.children = children
"""
class Solution:
def maxDepth(self, root: 'Node') -> int:
if not root:
return 0
elif root.children ==[]:
return 1
else :
height =[self.maxDepth(c) for c in root.children]
return max(height)+1
難度簡單483
翻轉一棵二叉樹。
示例：
輸入：
4
/ \
2 7
/ \ / \
1 3 6 9
輸出：
4
/ \
7 2
/ \ / \
9 6 3 1
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def invertTree(self, root: TreeNode) -> TreeNode:
if not root:
return None
root.left,root.right = root.right ,root.left
self.invertTree(root.left)
self.invertTree(root.right)
return root