leetcode98給定一個二叉樹，判斷其是否是一個有效的二叉搜索樹。
class Solution:
def isValidBST(self, root: TreeNode) -> bool:
inorders = self.inorder(root)
return inorders ==sorted(set(inorders))
def inorder(self,root):
if not root:
return []
return self.inorder(root.left)+[root.val]+self.inorder(root.right) letcode100 給定兩個二叉樹，編寫一個函數來檢驗它們是否相同。
class Solution:
def isSameTree(self, p, q):
deq = [(p,q)]
while deq:
p,q = deq.pop(0)
if not p and not q:
continue
if not p or not q:
return False
if p.val != q.val:
return False
deq.append((p.left,q.left))
deq.append((p.right,q.right))
return Trueleetcode104 二叉樹的最大深度。
class Solution:
def maxDepth(self, root: TreeNode) -> int:
if not root :
return 0
else:
left = self.maxDepth(root.left)
right = self.maxDepth(root.right)
return max(left, right) + 1- 從前序與中序遍歷序列構造二叉樹
class Solution:
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
if not preorder:
return None
x = preorder.pop(0)
node = TreeNode(x)
i = inorder.index(x)
node.left = self.buildTree(preorder[:i], inorder[:i])
node.right = self.buildTree(preorder[i:], inorder[i+1:])
return node - 從中序與後序遍歷序列構造二叉樹
class Solution:
def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
if not postorder:
return None
x = postorder.pop()
node = TreeNode(x)
i = inorder.index(x)
node.left = self.buildTree(inorder[:i],postorder[:i])
node.right = self.buildTree(inorder[i+1:],postorder[i:])
return node- 將有序數組轉換爲二叉搜索樹
class Solution:
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
if not nums:
return None
m = len(nums) // 2
node = TreeNode(nums[m])
node.left = self.sortedArrayToBST(nums[:m])
node.right = self.sortedArrayToBST(nums[m+1:])
return node - 平衡二叉樹
class Solution:
def isBalanced(self, root: TreeNode) -> bool:
if not root:
return True
if abs(self.height(root.left)-self.height(root.right))>1:
return False
return self.isBalanced(root.left) and self.isBalanced(root.right)
def height(self,root):
if not root:
return 0
return max(self.height(root.left),self.height(root.right))+1 - 二叉樹的最小深度
class Solution:
def minDepth(self, root: TreeNode) -> int:
if not root:
return 0
queue = [(1,root)]
while queue:
dd,roots = queue.pop(0)
children = [roots.left, roots.right]
if not any(children):
return dd
for sp in children:
if sp:
queue.append((dd+1,sp)) - 路徑總和
class Solution:
def hasPathSum(self, root: TreeNode, sum: int) -> bool:
if not root:
return False
sum -= root.val
if not root.left and not root.right:
return sum==0
return self.hasPathSum(root.left, sum) or self.hasPathSum(root.right, sum)- 路徑總和 II
class Solution:
def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:
res = []
result = []
self.dfs1(root,sum,res,result)
return result
def dfs(self,root, sum, res, result):
if not root:
return
sum -= root.val
if not root.left and not root.right and sum == 0:
res += [root.val]
result.append(res)
self.dfs(root.left,sum,res + [root.val],result)
self.dfs(root.right,sum,res + [root.val],result) - 二叉樹展開爲鏈表
class Solution:
def flatten(self, root: TreeNode) -> None:
"""
Do not return anything, modify root in-place instead.
"""
if not root or (not root.left and not root.right) :
return root
self.flatten(root.left)
self.flatten(root.right)
temp = root.right
root.right = root.left
root.left = None
while root.right:
root = root.right
root.right = temp - 填充每個節點的下一個右側節點指針 （bfs搜索）
class Solution:
def connect(self, root: 'Node') -> 'Node':
if not root:
return
stack = [root]
while stack:
temp = []
for sp in stack:
if sp.left:
temp.append(sp.left)
if sp.right:
temp.append(sp.right)
for i in range(len(temp)-1):
temp[i].next = temp[i+1]
stack = temp
return root - 求根到葉子節點數字之和
class Solution:
def sumNumbers(self, root: TreeNode) -> int:
if not root:
return 0
res = []
result = []
self.dfs(root,res,result)
return sum(map(lambda x: int(''.join([str(t) for t in x ])) ,result))
def dfs(self,root,res,result):
if not root:
return
if not root.left and not root.right:
res += [root.val]
result.append(res)
self.dfs(root.left,res+[root.val], result)
self.dfs(root.right,res+[root.val], result)
return result- 被圍繞的區域
class Solution:
def solve(self, board: List[List[str]]) -> None:
"""
Do not return anything, modify board in-place instead.
"""
if not board or not board[0]:
return
row = len(board)
col = len(board[0])
for i in range(row):
for j in [0,col-1]:
if board[i][j] == 'O':
self.dfs(i,j,board)
for i in [0,row-1]:
for j in range(1,col-1):
if board[i][j] == 'O':
self.dfs(i,j,board)
for i in range(row):
for j in range(col):
if board[i][j] == '*':
board[i][j] = 'O'
else:
board[i][j] = 'X'
def dfs(self,i,j,board):
m = len(board)
n = len(board[0])
board[i][j] = '*'
vec = [(0,1),(0,-1),(1,0),(-1,0)]
for dx, dy in vec:
nx , ny = i+dx ,j + dy
if 0 <= nx < m and 0 <= ny < n and board[nx][ny] == 'O':
self.dfs(nx, ny, board)- 島嶼數量
class Solution:
def numIslands(self, grid: List[List[str]]) -> int:
if not grid or not grid[0]:
return 0
m, n = len(grid), len(grid[0])
count = 0
for i in range(m):
for j in range(n):
if grid[i][j] == '1':
count += 1
self.dfs(i, j, grid)
return count
def dfs(self, i, j, grid):
vec = [(1, 0), (0, 1), (-1, 0), (0, -1)]
grid[i][j] = '*'
m, n = len(grid), len(grid[0])
for nx, ny in vec:
dx = i + nx
dy = j + ny
if 0 <= dx < m and 0 <= dy < n and grid[dx][dy] == '1':
self.dfs(dx, dy, grid)
if __name__ =='__main__':
ss = Solution()
dd = [["1","1","1","1","0"],["1","1","0","1","0"],["1","1","0","0","0"],["0","0","0","0","0"]]
ss.numIslands(dd)- 二叉樹的所有路徑
class Solution:
def binaryTreePaths(self, root: TreeNode) -> List[str]:
if not root:
return []
res = ''
result = []
self.dfs(root,res,result)
return result
def dfs(self,root,res,result):
if not root:
return
if not root.left and not root.right:
res = res + str(root.val)
result.append(res)
return result
self.dfs(root.left,res+str(root.val)+ '->', result)
self.dfs(root.right,res+str(root.val)+ '->', result)- 重新安排行程
class Solution:
def findItinerary(self, tickets) :
dic,ss = {},[]
for [sd,sf] in tickets:
if sd not in dic:
dic[sd] = [sf]
else:
dic[sd].append(sf)
dic[sd].sort()
print(dic)
def dfs(f): # 深搜函數
while f in dic and dic[f]:
dfs(dic[f].pop(0)) # 路徑檢索
ss.insert(0, f) # 放在最前
dfs('JFK')
return ss
if __name__ == '__main__':
s1 = Solution()
sdd = [["JFK", "KUL"], ["JFK", "NRT"], ["NRT", "JFK"]]
sd = [["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]]
s1.findItinerary(sdd)