【数据结构和算法】_09_广度 / 深度 优先搜索

a 夏天 提交于 2020-03-05 23:11:50


 


 

【一】 Breadth - First Search(广度优先搜索)

 

比较符合人类的思维的,常用的,搜索算法,必须掌握

 

  • 示意图(

 

  • 代码(不仅适用于树,也适用于图)
# python 广度优先搜索

def BFS(graph, start, end):

	# 队列,先进先出
	queue = []
	queue.append([start])
	# visited 里的数据表示被访问过了 (对二叉树来说没必要)
	visited.add(start)

	# 当队列不为空时
	while queue:
		# 将队列头元素取出
		node = queue.pop()
		# 放进被访问过的列表里
		visited.add(node)

		# 处理后继结点
		process(node)
		nodes = generate_related_nodes(node)
		queue.push(nodes)
		
	# other processing work
	...

 


 

【二】 Depth - First Search(深度优先搜索)

 

很多时候,我们在搜索一棵树的时候,站在计算机的角度,递归会默认用 stack (栈) 的数据结构来实现,而 BFS (广度优先搜索) 则是用的 queue (队列) ,DFS (深度优先搜索) 会更符合计算机的思维

 

  • 示意图(
     

 

  • 示意图(
     

 

  • 代码(递归写法,推荐)
# python 深度优先搜索

visited = set()
def dfs(None, visited):
	visited.add(node)
	# process current node here.
	...
	for next_node in node.children():
		if not next_node in visited:
			# 递归
			dfs(next_node, visited)

 

  • 代码(非递归写法)
# python 深度优先搜索

def DFS(self, tree):
	if tree.root is None:
		return []
	
	visited, stack = [], [tree.root]

	while stack:
		node = stack.pop()
		visited.add(node)

		process(node)
		nodes = generate_related_nodes(node)
		stack.push(nodes)
	
	# other processing work
	...

 


 

【三】 Interview(面试题)

 

【3.1】 LeetCode 102:Binary Tree Level Order(二叉树的层次遍历)

Input: [ 3, 9, 20, null, null, 15, 7 ]
Output: [ [ 3 ], [ 9, 20 ], [ 15, 7 ] ]

  • BFS(广度优先搜索)
# python BFS 广度优先搜索

class Solution(object):
	def levelOrder(self, root):
		if not root: return []

		result  = []
		queue = collections.deque()
		queue.append(root)

		# visited = set(root) # 对图而言的

		while queue:
			level_size = len(queue)
			current_level = []

			for _ in range(level_size):
				node = queue.popleft()
				current_level.append(node.val)
				if node.left: queue.append(node.left)
				if node.right: queue.append(node.right)
				
			result.append(current_level)
		return result
  • DFS(深度优先搜索)
# python DFS 深度优先搜索

class Solution(object):
	def levelOrder(self, root):
		if not root: return []
		self.result  = []
		self._dfs(root, 0)
		return self.result
	
	def _dfs(self, node, level):
		if not node: return

		if len(self.result) < level + 1:
			self.result.append([])
		
		self.result[level].append(node.val)
		
		# 递归实现
		self._dfs(node.left, level + 1)
		self._dfs(node.right, level + 1)

 

【3.2】 LeetCode 104:Max depth(二叉树的最大深度)

Input: [ 3, 9, 20, null, null, 15, 7, null, 4 ]
Output: 最大深度 4

  • BFS(广度优先搜索)
# python BFS 广度优先搜索 判断叶子节点

  • DFS(深度优先搜索)
# python DFS 深度优先搜索 判断叶子节点

class Solution:
	def maxDepth(self, root):
		if not root: return 0
		# 递归,先左后右
		return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))

 

【3.3】 LeetCode 111:Min depth(二叉树的最小深度)

Input: [ 3, 9, 20, null, null, 15, 7, null, 4 ]
Output: 最小深度 2

  • BFS(广度优先搜索)
# python BFS 广度优先搜索 判断叶子节点

  • DFS(深度优先搜索)
# python DFS 深度优先搜索 判断叶子节点

class Solution:
	def minDepth(self, root):
		if not root: return 0
		# 左子树深度
		if not root.left: return 1 + self.minDepth(root.right)
		# 右子树深度
		if not root.right: return 1 + self.minDepth(root.left)

		# divide and conquer (分而治之)
		leftMinDepth = self.minDepth(root.left)
		rightMinDepth = self.minDepth(root.right)
	
		# 看最小值
		result = 1 + min(leftMinDepth, rightMinDepth) 

 

【3.4】 LeetCode 22:Generate Parentheses(括号生成)

题目说明:给出 n 代表生成括号的对数,列出所有的有效括号的组合
Input: n = 3
Output: [ ‘((()))’, ‘(()())’, ‘(())()’, ‘()(())’, ‘()()()’]

  • BFS(深度优先搜索)
# python BFS 广度优先搜索 长度为2n 递归

class Solution(object):
	def generateParenthesis(self, n):
		self.list = []
		self._gen(0, 0, n "")
		return self.list

	# 递归函数
	def _gen(self, left, right, n, result):
		'''
		left:左括号用了多少个了
		right:右括号用了多少个了
		'''
		# 若全用完了
		if left == n and right == n:
			self.list.append(result)
			return
		# 若没用完
		if left < n:
			self._gen(left+1, right, n, result+'(')
		if right < n and left > right:
			self._gen(left, right+1, n, result+')')
易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!