代码随想录算法训练营day14 | 144.二叉树的前序遍历、145.二叉树的后序遍历、94.二叉树的中序遍历

二叉树理论

二叉树的种类

满二叉树：如果一颗二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这颗二叉树为满二叉树

完全二叉树：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层（h从1开始），则该层包含 1~ 2^(h-1) 个节点。

二叉搜索树：二叉搜索树是一个有序树。

• 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
• 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
• 它的左、右子树也分别为二叉排序树

平衡二叉搜索树：又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

二叉树的存储方式

可以链式存储，即使用链表；也可以顺序存储，即使用数组

二叉树遍历方式

深度优先遍历：先往深走，遇到叶子节点再往回走

• 前序遍历（递归法，迭代法）
• 中序遍历（递归法，迭代法）
• 后序遍历（递归法，迭代法）

广度优先遍历：一层一层的去遍历

• 层次遍历（迭代法）

二叉树的定义

class TreeNode:
    def __init__(self, val, left = None, right = None):
        self.val = val
        self.left = left
        self.right = right

二叉树深度优先遍历

本次不按照题目分别写题解，而是分为不同的方法同时写三种顺序遍历

递归遍历

写递归的三要素

• 参数和返回值
• 终止条件
• 单层逻辑

前序遍历
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        self.traversal(res, root)
        return res

    def traversal(self, res, cur):
        if not cur:
            return
        res.append(cur.val)
        self.traversal(res, cur.left)
        self.traversal(res, cur.right)

后序遍历
class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        self.traversal(res, root)
        return res

    def traversal(self, res, cur):
        if not cur:
            return
        self.traversal(res, cur.left)
        self.traversal(res, cur.right)
        res.append(cur.val)

中序遍历
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        self.traversal(res, root)
        return res

    def traversal(self, res, cur):
        if not cur:
            return
        self.traversal(res, cur.left)
        res.append(cur.val)
        self.traversal(res, cur.right)

有更简洁的写法，但是没上面的好理解

class Solution:
    def preorderTraversal(self, root: 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]:
        res = []
        if not root:
            return res
        stack = [root]
        while stack:
            cur = stack.pop()
            res.append(cur.val)
            if cur.right:
                stack.append(cur.right)
            if cur.left:
                stack.append(cur.left)
        return res


中序遍历
因为前序遍历要访问的元素和要处理的元素顺序是一致的，都是中间节点。而中序遍历是左中右，先访问二叉树顶部的节点，然后一层层向下访问，直到到达树左边的最底部，再开始处理节点，这就造成了访问顺序和处理顺序不一致
那么在使用迭代法写中序遍历，就需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素。
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        stack = []
        cur = root
        while cur or stack:
            if cur:
                stack.append(cur)
                cur = cur.left
            else:
                cur = stack.pop()
                res.append(cur.val)
                cur = cur.right
        return res


后序遍历，先序遍历是中左右，后续遍历是左右中，那么我们只需要调整一下先序遍历的代码顺序，就变成中右左的遍历顺序，然后在反转result数组，输出的结果顺序就是左右中了
class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # 中右左，反转之后 左右中即后序遍历
        res = []
        if not root:
            return res
        stack = [root]
        while stack:
            cur = stack.pop()
            res.append(cur.val)
            if cur.left:
                stack.append(cur.left)
            if cur.right:
                stack.append(cur.right)

        res.reverse()
        return res

统一迭代

二叉树的统一迭代法

中序遍历时只使用栈的话，无法同时解决访问节点（遍历节点）和处理节点（将元素放进结果集）不一致的情况。

那我们就将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。

如何标记呢，就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。 这种方法也可以叫做标记法。

后序遍历
class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # 后序遍历左右中，统一写法，空指针标记法
        res = []
        stack = []
        if root:
            stack.append(root)
        while stack:
            cur = stack.pop()
            if cur:
                stack.append(cur)
                stack.append(None)

                if cur.right:
                    stack.append(cur.right)
                if cur.left:
                    stack.append(cur.left)
            else:
                res.append((stack.pop()).val)
        return res


先序遍历
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # 先序遍历 中左右，统一迭代写法，空指针标记法
        res = []
        stack = []
        if root:
            stack.append(root)
        while stack:
            cur = stack.pop()
            if cur:
                if cur.right:
                    stack.append(cur.right)
                if cur.left:
                    stack.append(cur.left)

                stack.append(cur)
                stack.append(None)
            else:
                res.append((stack.pop()).val)

        return res



中序遍历
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # 中序遍历 左中右，统一迭代写法，空指针标记法
        res = []
        stack = []
        if root:
            stack.append(root)
        while stack:
            cur = stack.pop()
            if cur:
                if cur.right:
                    stack.append(cur.right)

                stack.append(cur)
                stack.append(None)

                if cur.left:
                    stack.append(cur.left)
            else:
                res.append((stack.pop()).val)

        return res