代码随想录｜Day12｜二叉树01｜理论基础、递归遍历、迭代遍历

1. 理论基础

1.1 定义

二叉树（Binary Tree）是每个节点最多有两个子节点的树结构。每个节点包含三个基本部分：一个数据元素（称为“键值”）、指向左子节点的指针和指向右子节点的指针。如果某个子节点不存在，相应的指针为空。

 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

二叉树有以下重要概念：

1. 根节点（Root Node）：指没有父节点的节点

2. 叶子结点（Leaf Node）：指没有子节点的节点

3. 深度（Depth）：从根节点到最远叶子节点的路径上的节点数

1.2 完全二叉树

除最后一层外，其他每一层都被完全填满，并且最后一层的所有节点都集中在左侧。

1.3 满二叉树

每一层都被完全填满。（满二叉树一定是完全二叉树）

1.4 二叉搜索树

节点的左子树只包含小于当前节点的数。

节点的右子树只包含大于当前节点的数。

左右子树也必须分别为二叉搜索树。

1.5 平衡二叉搜索树

它在二叉搜索树的基础上增加了一条额外的条件：树保持平衡，意味着树上任意一个节点的两个子树的高度差不会超过1 。

2. 二叉树的遍历

二叉树的遍历分为两种：

1. 深度优先遍历

2. 广度优先遍历

深度优先遍历着重于尽可能深地访问树的分支，直到达到叶子节点，然后回溯到之前的节点，访问其他的分支。深度优先遍历又可以细分为以下三种方式：

前序遍历（Pre-order Traversal）：访问根节点，遍历左子树，遍历右子树。

中序遍历（In-order Traversal）：遍历左子树，访问根节点，遍历右子树。

后序遍历（Post-order Traversal）：遍历左子树，遍历右子树，问根节点。

我们可以使用递归和迭代实现深度优先遍历。

广度优先遍历则是层级地访问树的节点，从根节点开始，一层一层向下，每层从左到右访问所有节点。这种遍历方式通常使用队列来实现：

层序遍历（Level-order Traversal）：从根节点开始，首先访问第一层（根节点），然后是第二层的节点，以此类推，直到访问到最底层的节点。 

3. 深度优先遍历的递归和迭代

144.二叉树的前序遍历

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # 前序遍历：递归
        # 中左右

        # 递归终止条件：节点为空
        if not root:
            return []
        
        left = self.preorderTraversal(root.left)
        right = self.preorderTraversal(root.right)
        # 访问根节点，遍历左子树，遍历右子树
        return [root.val] + left + right

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # 前序遍历：迭代
        # 中左右

        if not root:
            return []
            
        stack, result = [root], []
        while stack:
            node = stack.pop()
            if node:
                result.append(node.val)
                stack.append(node.right)  # 先右后左，保证左子树先处理
                stack.append(node.left)
        return result

94.二叉树的中序遍历

class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # 中序遍历：递归
        # 左中右
        if not root:
            return []
        
        left = self.inorderTraversal(root.left)
        right = self.inorderTraversal(root.right)

        return left + [root.val] + right

class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # 中序遍历：迭代
        # 左中右
        if not root:
            return []
        stack, result = [], []
        # 首先遍历根节点，但由于中序需要首先处理左子树
        # 不能先将根节点入栈
        current = root
        while current or stack:
            
            while current:
                stack.append(current)
                current = current.left
            # 访问节点
            current = stack.pop()
            result.append(current.val)
            current = current.right
        return result

 145.二叉树的后序遍历

class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # 后序遍历：递归
        # 左右中

        if not root:
            return []
        
        left = self.postorderTraversal(root.left)
        right = self.postorderTraversal(root.right)

        return left + right + [root.val]

class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # 后序遍历：迭代
        # 只需对前序迭代的代码稍作修改
        # 前序遍历：中左右
        # 交换左右顺序：中右左
        # 反转数组：左右中
        if not root:
            return []
        
        stack, result = [root], []
        while stack:
            node = stack.pop()
            if node:
                result.append(node.val)
                stack.append(node.left)
                stack.append(node.right)
        return result[::-1]