代码随想录算法训练营第十四天| 第六章二叉树：理论基础，递归遍历，迭代遍历，统一迭代（python）

二叉树理论基础

1. 种类：

满二叉树：全部满的二叉树；

完全二叉树：除了底层都是满的，底层从左到右连续；

堆：完全二叉树，同时满足父子节点的相应顺序关系；

二叉搜索树：对布局没要求，对节点大小顺序有要求，左<根<右；

平衡二叉搜索树：左子树和右子树高度之差绝对值 <= 1;

2.存储方式：

链式存储，线性存储；

理解如何用链表自己构造二叉树，基本数据结构的定义要能自己实现；

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

3.遍历：

深度优先搜索的思想（递归法，迭代法）：前序中序后序遍历

广度优先搜索的思想（用队列迭代）：层序遍历

二叉树的递归遍历

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 preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        def preorder(root):
            if not root:
                return
            res.append(root.val)
            preorder(root.left)
            preorder(root.right)
        
        res = []
        preorder(root)
        return res

2. 后序遍历

class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        def postorder(root):
            if not root:
                return 
            postorder(root.left)
            postorder(root.right)
            res.append(root.val)
        
        res = []
        postorder(root)
        return res

3. 中序遍历

class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        def inorder(root):
            if not root:
                return 
            inorder(root.left)
            res.append(root.val)
            inorder(root.right)
            
        res = []
        inorder(root)
        return res

二叉树的迭代遍历

1.前序遍历

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        st = [root] #栈
        res = [] #记录结果
        while st:
            #将栈顶元素加入到结果列表中
            node = st.pop()
            res.append(node.val)
            #先加入右孩子再加入左孩子，这样栈先弹出左孩子再弹出右孩子
            if node.right: 
                st.append(node.right)
            if node.left: 
                st.append(node.left)
        return res

2.后序遍历

class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        st = [root]
        res = []
        while st:
            node = st.pop()
            res.append(node.val)
            #按左右顺序推进栈里，出来是右左
            #加上先处理了根节点，就是根右左，翻转就是左右根的后序遍历顺序
            if node.left:
                st.append(node.left)
            if node.right:
                st.append(node.right)
        return res[::-1]

3.中序遍历

class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        st = [] #存储中间值的栈
        res = [] #存储结果
        cur = root #遍历树的指针
        while cur or st: #如果树遍历完了且栈为空了，任务就结束了
            if cur:
                st.append(cur)
                cur = cur.left #一路向左
            else: #左边走到尽头了
                cur = st.pop() #回栈中记录的节点
                res.append(cur.val) #记录根节点
                cur = cur.right #检查右节点
        return res

 

二叉树的统一迭代法

通过用空节点标记来实现代码表达上统一

1.前序遍历

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        st = [root] #栈
        res = [] #记录结果
        while st:
            node = st.pop()
            if node:
                if node.right: #右
                    st.append(node.right)
                if node.left: #左
                    st.append(node.left)
                st.append(node) #根
                st.append(None) #标记
            else:
                node = st.pop()
                res.append(node.val)
        return res

2.后序遍历

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        st = [root]
        res = []
        while st:
            node = st.pop()
            if node:
                st.append(node) #根
                st.append(None) #标记
                if node.right: #右
                    st.append(node.right)
                if node.left: #左
                    st.append(node.left)
            else:
                node = st.pop()
                res.append(node.val)
        return res

3.中序遍历

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        st = [root] #存储中间值的栈
        res = [] #存储结果
        while st:
            node = st.pop()
            if node:
                if node.right: #右
                    st.append(node.right)  
                st.append(node) #根
                st.append(None) #标记
                if node.left: #左
                    st.append(node.left)
            else: 
                node = st.pop()
                res.append(node.val)
        return res