DFS BFS

Author: genkimaru

README.md

@@ -6,6 +6,8 @@
     - 杨辉三角
 - 图
     - dijkstra 最短路径
+    - 深度优先算法
+    - 广度优先算法
 - 滑动窗口
     - 最小包含窗口
 - 排序

src/tree/breadth_first_search.py

@@ -0,0 +1,49 @@
+from collections import deque
+from typing import List
+
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+def levelOrder(root: TreeNode) -> List[List[int]]:
+    if not root:
+        return []
+    
+    queue = deque([root])
+    result = []
+    
+    while queue:
+        level_size = len(queue)
+        level_nodes = []
+        
+        for _ in range(level_size):
+            node = queue.popleft()
+            level_nodes.append(node.val)
+            
+            if node.left:
+                queue.append(node.left)
+            if node.right:
+                queue.append(node.right)
+        
+        result.append(level_nodes)
+    
+    return result
+
+node1 = TreeNode(1)
+node2 = TreeNode(2)
+node3 = TreeNode(3)
+node4 = TreeNode(4)
+node5 = TreeNode(5)
+node6 = TreeNode(6)
+node7 = TreeNode(7)
+node1.left = node2
+node1.right = node3
+node2.left = node4
+node2.right = node5
+node3.left = node6
+node3.right = node7
+
+result = levelOrder(node1)
+print(result)

src/tree/depth_first_search.py

@@ -0,0 +1,59 @@
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+def preorderTraversal(root: TreeNode) -> List[int]:
+    if not root:
+        return []
+    
+    result = []
+    stack = [root]
+    
+    while stack:
+        node = stack.pop()
+        result.append(node.val)
+        
+        if node.right:
+            stack.append(node.right)
+        if node.left:
+            stack.append(node.left)
+    
+    return result
+
+def inorderTraversal(root: TreeNode) -> List[int]:
+    if not root:
+        return []
+    
+    result = []
+    stack = []
+    node = root
+    
+    while stack or node:
+        while node:
+            stack.append(node)
+            node = node.left
+        node = stack.pop()
+        result.append(node.val)
+        node = node.right
+    
+    return result
+
+def postorderTraversal(root: TreeNode) -> List[int]:
+    if not root:
+        return []
+    
+    result = []
+    stack = [root]
+    
+    while stack:
+        node = stack.pop()
+        result.append(node.val)
+        
+        if node.left:
+            stack.append(node.left)
+        if node.right:
+            stack.append(node.right)
+    
+    return result[::-1]

src/tree/广度优先算法.md

@@ -0,0 +1,11 @@
+这个实现使用了一个`队列(deque)`来实现`广度优先遍历`。算法的流程如下:
+
+- 首先判断根节点是否为空,如果为空则返回一个空列表。
+- 将根节点加入到队列中。
+- 开始循环,直到队列为空。在每次循环中:
+    - 获取当前队列的长度,即当前层级的节点数量。
+    - 创建一个空列表来存储当前层级的节点值。
+    - 依次从队列中取出节点,将节点值添加到当前层级的列表中,并且如果节点有左右子节点,则将它们加入到队列中。
+    - 将当前层级的列表添加到最终结果中。
+    - 循环结束后,返回最终的结果列表。
+- 这个算法的时间复杂度为O(n),其中n是二叉树的节点数量,因为我们需要访问每个节点一次。空间复杂度为O(n),因为在- 最坏情况下,我们需要在队列中存储所有的节点。

src/tree/深度优先算法.md

@@ -0,0 +1,24 @@
+这里我们实现三种深度优先遍历的方法:前序遍历、中序遍历和后序遍历。
+这个实现使用了`栈(list)`来实现`深度优先遍历`。算法的流程如下:
+
+## 前序遍历:
+首先判断根节点是否为空,如果为空则返回一个空列表。
+创建一个空列表来存储遍历结果,以及一个栈。
+将根节点压入栈中,然后开始循环,直到栈为空。
+在每次循环中,从栈中弹出一个节点,将其值添加到结果列表中,然后将其右子节点和左子节点(如果存在)依次压入栈中。
+最终返回结果列表。
+## 中序遍历:
+首先判断根节点是否为空,如果为空则返回一个空列表。
+创建一个空列表来存储遍历结果,以及一个栈。
+将当前节点设置为根节点,然后开始循环,直到当前节点为空且栈为空。
+在每次循环中,如果当前节点不为空,则将其压入栈中,并将当前节点设置为其左子节点。
+如果当前节点为空,则从栈中弹出一个节点,将其值添加到结果列表中,并将当前节点设置为其右子节点。
+最终返回结果列表。
+## 后序遍历:
+首先判断根节点是否为空,如果为空则返回一个空列表。
+创建一个空列表来存储遍历结果,以及一个栈。
+将根节点压入栈中,然后开始循环,直到栈为空。
+在每次循环中,从栈中弹出一个节点,将其值添加到结果列表的开头。
+然后将该节点的左子节点和右子节点(如果存在)依次压入栈中。
+最终返回结果列表。
+这些算法的时间复杂度都为O(n),其中n是二叉树的节点数量,因为我们需要访问每个节点一次。空间复杂度为O(n),因为在最坏情况下,我们需要在栈中存储所有的节点。