【leetcode刷刷】二叉树基础

理论基础

1. 二叉搜索树，左小于右
2. 平衡二叉搜索树AVL：左右两个子树的高度差绝对值不超过1
3. 二叉树的存储方式：链式存储——链表；顺序存储——数组
4. 顺序存储：如果父节点的数组下标是 i，那么它的左孩子就是 i * 2 + 1，右孩子就是 i * 2 + 2
5. 遍历方式

• 深度优先遍历
  - 前序遍历（迭代法，递归法）
  - 中序遍历（迭代法，递归法）
  - 后序遍历（迭代法，递归法）
• 广度优先遍历
  - 层次遍历（迭代法）
  

递归遍历

中序：

# 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 inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
    	# 终止条件
        if root is None:
            return []
        # 递归
        left = self.inorderTraversal(root.left)
        right = self.inorderTraversal(root.right)
        return left + [root.val] + right

迭代遍历

中序：相当于是把左节点压入栈，当处理中间节点的时候再读出来？每次把左节点全部压入栈，从自身开始压，因此读出来的时候就是最左边先读，然后是自身。读自身的时候考虑右节点，如果存在的话，就继续把右节点的左分支全部压入栈。这个栈实现的其实是左中的顺序，右是在处理中的时候处理的。

# 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 inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # 迭代
        if not root:
            return []
        stack = []
        # stack.append(root.val)
        res = []
        cur = root
        while cur or stack:
            if cur:
                stack.append(cur)
                cur = cur.left  # 到达最左节点
            else:
                cur = stack.pop()  # 栈顶pop出来，中间
                res.append(cur.val)
                cur = cur.right
        return res

        # 递归
        if root is None:
            return []
        left = self.inorderTraversal(root.left)
        right = self.inorderTraversal(root.right)
        return left + [root.val] + right

前序：

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # 迭代
        if not root:
            return []
        stack = [root]
        res = []
        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


        # 递归
        if not root:
            return []
        left = self.preorderTraversal(root.left)
        right = self.preorderTraversal(root.right)
        return [root.val] + left + right

后序：

# 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 postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # 迭代：左右中--->中右左
        if not root:
            return []
        stack = [root]
        res = []
        while(stack):
            node = stack.pop()
            res.append(node.val)
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
        return res[::-1]

统一迭代

好复杂，不想学…