Day2-二叉树

tips：本系列内容均来自于：代码随想录

二叉树的形式

二叉树主要有两种形式：满二叉树和完全二叉树

满二叉树

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

完全二叉树

完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层（h从1开始），则该层包含 1~ 2^(h-1) 个节点。

二叉搜索树

前面介绍的树，都没有数值的，而二叉搜索树是有数值的了，二叉搜索树是一个有序树。

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

• 

平衡二叉搜索树

平衡二叉搜索树：又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

 二叉树的遍历方式

1. 深度优先遍历：先往深走，遇到叶子节点再往回走。
2. 广度优先遍历：一层一层的去遍历。

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

最后再说一说二叉树中深度优先和广度优先遍历实现方式，我们做二叉树相关题目，经常会使用递归的方式来实现深度优先遍历，也就是实现前中后序遍历，使用递归是比较方便的。

之前我们讲栈与队列的时候，就说过栈其实就是递归的一种实现结构，也就说前中后序遍历的逻辑其实都是可以借助栈使用递归的方式来实现的。

而广度优先遍历的实现一般使用队列来实现，这也是队列先进先出的特点所决定的，因为需要先进先出的结构，才能一层一层的来遍历二叉树。

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

二叉树的递归遍历 

递归的三步骤： 

1. 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。

2. 确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。

3. 确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

class TreeNode(object):
    def __init__(self, value, left=None, right=None):
        self.value = value
        self.left = left
        self.right = right
# 前序遍历
def Preorder(self, root):
    res=[]
    def dfs(root):
        if not root:
            return
        res.append(root.value)
        dfs(root.left)
        dfs(root.right)
    dfs(root)
    return res

# 中序遍历
def Inorder(self, root):
    res=[]
    def dfs(root):
        if not root:
            return
        dfs(root.left)
        res.append(root.value)
        dfs(root.right)

    dfs(root)
    return res

# 后序遍历
def Postorder(self, root):
    res=[]
    def dfs(root):
        if not root:
            return
        dfs(root.left)
        dfs(root.right)
        res.append(root.value)

    dfs(root)
    return res

 二叉树的迭代遍历

# 前序迭代遍历
def preorder_travel(self,root):
    if not root:
        return []
    res=[]
    stack = [root]
    while stack:
        node=stack.pop()
        # 中节点先处理
        res.append(node.value)
        # 先处理右节点
        if node.right:
            stack.append(node.right)
        # 先处理左节点
        if node.left:
            stack.append(node.left)
    return res

# 后序迭代遍历
def postorder_travel(self,root):
    if not root:
        return []
    stack = [root]
    res = []
    while stack:
        node=stack.pop()
        # 中节点先处理
        res.append(node.value)
        # 先处理右节点
        if node.left:
            stack.append(node.left)
        # 先处理左节点
        if node.right:
            stack.append(node.right)
    return res[::-1]

# 中序迭代遍历
def inorder_travel(self,root):
    if not root:
        return []
    stack=[]
    res=[]
    cur=root
    while cur or stack:
        if cur:
            stack.append(cur)
            cur=cur.left
        else:
            cur=stack.pop()
            res.append(cur.value)
            cur=cur.right
    return res

二叉树的层序遍历

力扣102.层序遍历

就是BFS，访问所有节点，按层保存

import collections
class Solution:
    def levelOrder(self, root):
        if not root:
            return []
        res=[]
        queue=collections.deque([root])
        while queue:
            size=len(queue)
            tmp=[]
            for i in range(size):
                cur=queue.popleft()
                tmp.append(cur.value)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            res.append(tmp)
        return res

力扣199.二叉树的右视图

照常访问所有节点，但只保留每层最后一个数据也就是每层最后一个节点的值

    def rightlevel_travel(self, root):
        if not root:
            return []
        res=[]
        queue=collections.deque([root])
        while queue:
            size=len(queue)
            for i in range(size):
                cur = queue.popleft()
                if i==size-1:
                    res.append(cur.value)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
        return res