算法题day13(补卡4.30号，51-5.3放假）：

一、今日复习二叉树知识：

1. 在解题过程中一般会碰到两种树：①满二叉树，②完全二叉树。

①满二叉树：

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

②完全二叉树：

除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。（也就是说最下面的节点不可能存在右节点，不存在左节点的情况）

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

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

①平衡二叉搜索树

性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

3.二叉树的存储方式：①顺序存储②链式存储

①顺序存储：用数组的方式存储二叉树。如果父节点的数组下标是i，那么它的左孩子就是i*2 + 1，右孩子就是i*2 + 2.

②链式存储：节点元素+左右指针

4.二叉树的遍历方式：

①深度优先遍历：前序遍历（中左右）、中序遍历（左中右）、后序遍历（左右中）

②广度优先遍历：层次遍历

4.python定义二叉树的方式：

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

二、leetcode题目：

1.leetcode题目 144 二叉树的前序遍历（easy）：

①递归法：

# 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]:
        res = []
        def dfs(node):
            if node is None:
                return 
            res.append(node.val)
            dfs(node.left)
            dfs(node.right)
        dfs(root)
        return res

②迭代法：

# 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]:
        res = []
        stack = []
        if root:
            stack.append(root)
        while stack:
            node = stack.pop()
            if node!=None:
                if node.right:
                    stack.append(node.right)  #右
                if node.left:
                    stack.append(node.left)   #左
                stack.append(node)
                stack.append(None)
            else:
                node = stack.pop()            #中
                res.append(node.val)
        return res
            

2.leetcode题 145 二叉树的后序遍历（easy）：

①递归法：

# 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]:
        res = []
        def dfs(node):
            if node is None:
                return
            dfs(node.left)
            dfs(node.right)
            res.append(node.val)
        dfs(root)
        return res

②迭代法：

# 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]:
        res = []
        stack = []
        if root:
            stack.append(root)
        while stack:
            node = stack.pop()
            if node!=None:
                stack.append(node)
                stack.append(None)
                if node.right:
                    stack.append(node.right)
                if node.left:
                    stack.append(node.left)
            else:
                node = stack.pop()
                res.append(node.val)
        return res
        

3.leetcode题目94 二叉树的中序遍历（easy）：

①递归法：

# 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]:
        res = []
        def dfs(node):
            if node is None:
                return
            dfs(node.left)
            res.append(node.val)
            dfs(node.right)
        dfs(root)
        return res

②迭代法：

# 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]:
        res = []
        stack= []
        if root:
            stack.append(root)
        while stack:
            node = stack.pop()
            if node!= None:
                if node.right:
                    stack.append(node.right)
                stack.append(node)
                stack.append(None)
                if node.left:
                    stack.append(node.left)
            else:
                node = stack.pop()
                res.append(node.val)
        return res