代码随想录算法训练营Day14 | 二叉树(1/9) 二叉树理论基础、1.递归遍历2.迭代遍历3.统一迭代-CSDN博客

本文链接：https://blog.csdn.net/Hanzq1997/article/details/132295084

1. 二叉树理论基础

1.1 二叉树的种类

满二叉树

如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。
k为层数时，满二叉树的结点数量为2^k -1

完全二叉树：

在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点是从左到右连续的。

二叉搜索树

时间复杂度O(logn)
若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；

平衡二叉搜索树

又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
插入元素、查询元素都是O(logn)

1.2 二叉树的存储方式

二叉树可以

链式存储
线性存储。

那么链式存储方式就用指针，线性存储的方式就是用数组。
顾名思义线性存储的元素在内存是连续分布的，而链式存储则是通过指针把分布在各个地址的节点串联一起。

1.3 二叉树的遍历

深度优先遍历
- 前序遍历（递归法，迭代法）
- 中序遍历（递归法，迭代法）
- 后序遍历（递归法，迭代法）
广度优先遍历
- 层次遍历（迭代法）(Day15 会用到)

在深度优先遍历中，前中后，其实指的就是中间节点的遍历顺序，

前序遍历：中左右
中序遍历：左中右
后序遍历：左右中

1.4 二叉树的定义

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

2. 二叉树的递归遍历 (LeetCode 144. 145. 94.)

为了避免写递归的时候被绕进去，可以用以下三步曲来考虑问题：

确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数，并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

练习：前序遍历 LC144

144. Binary Tree Preorder Traversal

Given the root of a binary tree, return the preorder traversal of its nodes' values.

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        result = []
        if not root:
            return []
        
        left = self.preorderTraversal(root.left)
        right = self.preorderTraversal(root.right)
        result = [root.val] + left + right # PreOrder: middle + left + right
        return result

练习：后序遍历 LC 145

145. Binary Tree Postorder Traversal

Given the root of a binary tree, return the postorder traversal of its nodes' values.

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

练习：中序遍历 LC 94

94. Binary Tree Inorder Traversal

Given the root of a binary tree, return the inorder traversal of its nodes' values.

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

        result = left + [root.val] + right
        return result

3. 二叉树的迭代遍历

非递归的方法，就是用栈。要注意：尽管前序遍历的时候，是中左右，但是入栈的时候要先进右子节点，这样才能保证出栈时候是左子节点先出。

144. Binary Tree Preorder Traversal

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        result = []
        if not root:
            return []
        stack = [root]
        result = []
        while stack:
            node = stack.pop()
            # Operate middle node
            result.append(node.val)
            # right child enter stack first
            if node.right:
                stack.append(node.right)
            # left child enter stack later
            if node.left:
                stack.append(node.left)
        return result

145. Binary Tree Postorder Traversal

class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
           return []
        stack = [root]
        result = []
        while stack:
           node = stack.pop()
           # Operate middle first
           result.append(node.val)
           # left child enter stack first
           if node.left:
               stack.append(node.left)
           # right child enter stack later
           if node.right:
               stack.append(node.right)
        # reverse final array
        return result[::-1]

94. Binary Tree Inorder Traversal

class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        stack = []  # we can not add root into stack first
        result = []
        cur = root
        while cur or stack:
            # iteration left child fiest
            if cur:     
                stack.append(cur)
                cur = cur.left		
            # operate stack top    
            else:		
                cur = stack.pop()
                result.append(cur.val)
                # select right node
                cur = cur.right	
        return result