leetcode94. 二叉树的中序遍历

# 给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。
# 示例 1：
# 输入：root = [1,null,2,3]
# 输出：[1,3,2]
# 示例 2：
#
# 输入：root = []
# 输出：[]

# 示例 3：
# 输入：root = [1]
# 输出：[1]


# 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


class Solution:

    def __init__(self):
        self.result = []

    def inorderTraversal(self, root: TreeNode) -> list[int]:
        """
        中序 左 根 右
        """

        if root is None:
            return self.result

        self.inorderTraversal(root.left)
        self.result.append(root.val)
        self.inorderTraversal(root.right)

        return self.result

144. 二叉树的前序遍历

144. 二叉树的前序遍历

# 给你二叉树的根节点 root ，返回它节点值的 前序 遍历。
#
# 示例 1：
#
#
# 输入：root = [1,null,2,3]
# 输出：[1,2,3]
# 示例 2：
#
# 输入：root = []
# 输出：[]
# 示例 3：
#
# 输入：root = [1]
# 输出：[1]
# 示例 4


# 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


class Solution:

    def __init__(self):
        self.results = list()

    def preorderTraversal(self, root: TreeNode) -> list[int]:
        """
        前序遍历 根 左 右
        """
        if root is None:
            return self.results

        self.results.append(root.val)
        self.preorderTraversal(root.left)
        self.preorderTraversal(root.right)

        return self.results

590. N 叉树的后序遍历

590. N 叉树的后序遍历

# 给定一个 n 叉树的根节点 root ，返回 其节点值的 后序遍历 。
#
# n 叉树 在输入中按层序遍历进行序列化表示，每组子节点由空值 null 分隔（请参见示例）


# 示例 1：
# 输入：root = [1,null,3,2,4,null,5,6]
# 输出：[5,6,3,2,4,1]

# 示例 2：
# 输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
# 输出：[2,6,14,11,7,3,12,8,4,13,9,10,5,1]


# 提示：
#
# 节点总数在范围 [0, 104] 内
# 0 <= Node.val <= 104
# n 叉树的高度小于或等于 1000
#
#
# 进阶：递归法很简单，你可以使用迭代法完成此题吗?


"""
# Definition for a Node.
class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""
class Solution:

    def postorder(self, root: 'Node') -> list[int]:
        """
        后序遍历 左 右 根
        """
        results = list()

        def dfs(root):

            # 中断逻辑
            if root is None:
                return

            # 如果还有孩子节点 那继续下探
            for ch in root.children:
                dfs(ch)

            # 如果没有孩子节点 那就记录值
            results.append(root.val)

        dfs(root)
        return results

589. N 叉树的前序遍历

589. N 叉树的前序遍历

class Solution:
    def preorder(self, root: 'Node') -> list[int]:
        """
        前序遍历 根 左 右
        """
        results = list()

        # 中断逻辑
        if root is None:
            return results

        # 继续下探
        def dfs(node):
            if not node:
                return results

            results.append(node.val)

            for ch in node.children:
                dfs(ch)

        dfs(root)
        return results

429. N 叉树的层序遍历

429. N 叉树的层序遍历

# 输入：root = [1,null,3,2,4,null,5,6]
# 输出：[[1],[3,2,4],[5,6]]

class Solution:

    def levelOrder(self, root: 'Node') -> list[list[int]]:
        """
        思路: 使用广度搜索

        维护一个双端队列 队列中只存储当前层级的节点

        遍历队列
        - 每次开始时 记录当前队列中的元素总量 即当前层级的节点总数
        - 维护一个level级别的列表 每次将同一层级节点的元素追加进来
        - 遍历每个节点的子节点 将其加入到队列的尾端 准备进行下一轮遍历
        """
        results = list()
        if not root:
            return results

        # 定义双端队列
        double_quue = list()
        double_quue.append(root)

        while double_quue:
                
            # 存储当前层级的节点
            level_list = list()
            
            # 每次循环开始时 记录当前层级的节点总数 
            # 因为双端队列会不断的追加子节点 所以这一次只遍历当前层级的节点
            current_level_no = len(double_quue)

            for index in range(0, current_level_no):
                level_list.append(double_quue[index].val)
                
                # 将子节点的信息 追加到双端队列的尾部
                for ch in double_quue[index].children:
                    double_quue.append(ch)
            
            # 将已经处理完的节点从队列中踢出去 下一次遍历就是子节点了
            double_quue = double_quue[current_level_no:]

            results.append(level_list)

        return results