代码随想录Day15 | 二叉树基础

0. 二叉树基础

二叉树作为一种常见的数据结构，但是其中的很多问题我都没有深入理解过。因此这次也是一个从头开始熟悉二叉树内容的好机会。

二叉树种类

理论基础里提到的二叉树种类有四种：满二叉树、完全二叉树、二叉搜索树、平衡二叉搜索树。

满二叉树

重点是：各个节点的度只能为0或者2，并且度为0的节点只能位于一层上，不能位于不同层。

完全二叉树

这个很容易出错，重点有两个，一是除了最底层所有层都填满了，二是最底层的所有节点都集中在这一层的左边部分。需要满足这两个条件才可以。

二叉搜索树

前面的树都没有数值，这里开始有数值了。如果存在左子树，左子树的值小于根节点的值；如果存在右子树，右子树的值大于根节点的值。

平衡二叉搜索树

这个树睡一棵空树，或者左右两个子树高度差的绝对值不超过1，并且左右两层都是两个二叉搜索树。

二叉树的存储方式

存储方式一般是两种：1）链式存储，用的是指针来完成；2）顺序存储，用的是数组来完成。

二叉树的遍历方式

文档里给的记忆方式很不错：前序遍历——中左右；中序遍历——左中右；后续遍历——左右中。

二叉树的定义

本python用户就记一下python的定义吧：

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

1. 二叉树的递归遍历

好！开始认真做二叉树的题目了！
首先在递归遍历方面，要确认的事情有三个：1）递归函数中的参数是什么；2）什么时候递归结束；3）确定单层递归的逻辑。
那对于二叉树递归，不论是前中后序，其实中间本质都是一样，先遍历左边的点，再遍历右边的点，关键是在返回的时候返回的东西不一致。

前序遍历

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 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 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]

2. 二叉树的迭代遍历

这种方式相比递归来说相对麻烦一点点，但是思路是清晰的，前序和后续思路一致，都是遍历到的点直接进入栈，到那时中序就不一样，即使遍历了也不能立马进入栈。

前序遍历

class Solution:
    def preorderTraversal(self, root: Optional[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

后续遍历

和前序遍历一模一样，因为“左右中 = （中后左）反过来”，所以注意一下左右子节点的入栈顺序即可。

class Solution:
    def postorderTraversal(self, root: Optional[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]

中序遍历

中序遍历相对复杂。思想上来说，需要一个指针cur来确定目前遍历的点的位置，先把它压入栈，再把指针指向它的左子节点；同时，要在cur完全遍历完的时候再考虑pop，并把pop出来的点放进result，指针变为current的右子节点。
需要注意的单层边界条件是if cur之后是append它本身，并非append它的left。

class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        result = []
        stack = []
        cur = root
        while cur or stack:
            if cur:
                stack.append(cur)
                cur = cur.left
            else:
                cur = stack.pop()
                result.append(cur.val)
                cur = cur.right
        return result