class TreeNode:
def __init__(self, val):
self.val = val
self.left = None
self.right = None
Tree Search
Depth First Search (DFS)
方法 1:使用递归
def dfs(root):
if not root:
return
# preorder: action on root.val
left_val = dfs(root.left)
# inorder: action on root.val
right_val = dfs(root.right
# postorder: action on root.val
return func(left_val, right_val)
方法 2:使用栈迭代
def dfs_preorder(node):
if not node:
return
stack = [node]
while stack:
node = stack.pop()
# from right to left
if node.right:
stack.append(node.right)
if node.left:
stack.append(node.left)
def dfs_postorder(node):
if not node:
return
stack = [node]
ret = []
while stack:
node = stack.pop()
ret.append(node.val)
if node.left:
stack.append(node.left)
if node.right:
stack.append(node.right)
return ret[::-1]
Breadth First Search (BFS)
方法1:使用 list
def bfs(root):
if not root:
return
q = [root]
while q:
nq = []
for node in q:
if node.left:
nq.append(node.left)
if node.right:
nq.append(node.right)
q = nq
方法2:使用 dequeue
from collections import dequeue
def bfs(root):
if not root:
return
q = dequeue([root])
while q:
node = q.popleft()
if node.left:
q.append(node.left)
if node.right:
q.append(node.right)
# Given a non-empty binary search tree, return the node
# with minimum key value found in that tree.
def minValueNode(node):
current = node
while current.left is not None:
current = current.left
return current
def deleteNode(root, key):
if root is None:
return root
if key < root.key:
root.left = deleteNode(root.left, key)
elif key > root.key:
root.right = deleteNode(root.right, key)
else:
if root.left is None:
root = root.right
return root
elif root.right is None:
root = root.left
return root
next_node = minValueNode(root.right)
root.key = next_node.key
root.right = deleteNode(root.right, next_node.key)
return root
Time complexity: O(h)
Traversal
In-order traversal of BST always produces sorted output
we can construct a BST with only Preorder or Postorder or Level Order traversal.
number of unique BSTs with n distinct keys is Catalan Number