leetcode10: 二叉树的层次遍历 II(107)、将有序数组转换为二叉搜索树（108）、平衡二叉树（110）

1.二叉树的层次遍历 II(107)

给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

思路：队列

点1：层为空的时候，终止。点2：遍历当前层的的节点的时候，将其的左右孩子节点放在一层中。点3,：遍历结束以后，要更新层。

# Definition for a binary tree node.
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class Solution:
    def levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
        quene = []                             #存放结果
        cur = [root]                           #用于存储每层的所有节点
        while cur:                             #最后一层的终止循环
            cur_layer_val = []                 #存放当前层的值
            next_layer_node = []               #存放下一层的节点
            for node in cur:                   #遍历当前层节点获取所有val
                if node:
                    cur_layer_val.append(node.val)
                    next_layer_node.extend([node.left,node.right])
            if cur_layer_val:                  
                quene.insert(0,cur_layer_val)  #后面层的节点值放在前面
            cur = next_layer_node              #更新层
        return quene

2.将有序数组转换为二叉搜索树（108）

将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

思路：

点1：平衡二叉树是左右高度相差不超过1.。点2：二叉搜索树是左子树<节点值，右子树>节点值。点3：有序数组，可以利用中序遍历。

点4：利用递归获取当前节点和左右子节点。

# Definition for a binary tree node.
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
        if not nums:
            return 
        n = (len(nums)-1) // 2                      #得到中位位置索引
        root = TreeNode(nums[n])                    #中间位置为头结点
        root.left = self.sortedArrayToBST(nums[:n]) #递归
        root.right = self.sortedArrayToBST(nums[n+1:])
        return root

知识点：二叉搜索树、平衡二叉树。

参考链接：https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree/solution/jiang-you-xu-shu-zu-zhuan-huan-wei-er-cha-sou-su-2/

3.平衡二叉树（110）

给定一个二叉树，判断它是否是高度平衡的二叉树。本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

思路1：自顶向上，递归

点1：每个节点 的左右两个子树的高度差的绝对值不超过1，为平衡二叉树。

点2：计算所有节点的高度差均满足点1的要求，则我们递归所有的节点。

点3：设计一个函数能够计算当前节点的的深度。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        if not root:
            return True
        return abs(self.isMaxDepth(root.left)-self.isMaxDepth(root.right))<=1 and self.isBalanced(root.left) and self.isBalanced(root.right)
       
    
    def isMaxDepth(self,p):
        if not p:
            return 0
        return max(self.isMaxDepth(p.left),self.isMaxDepth(p.right))+1

思路2：自低向上，递归

终止条件：当DFS越过叶子节点时，返回高度0；
返回值：从底至顶，返回以每个节点root为根节点的子树最大高度(左右子树中最大的高度值加1：max(left,right) + 1)；
当我们发现有一例 左/右子树高度差 ＞ 1 的情况时，代表此树不是平衡树，返回-1；
当发现不是平衡树时，后面的高度计算都没有意义了，因此一路返回-1，避免后续多余计算。

class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        return self.depth(root) != -1

    def depth(self, root):
        if not root: return 0
        left = self.depth(root.left)
        if left == -1: return -1
        right = self.depth(root.right)
        if right == -1: return -1
        return max(left, right) + 1 if abs(left - right) < 2 else -1

参考链接：https://leetcode-cn.com/problems/balanced-binary-tree/solution/balanced-binary-tree-di-gui-fang-fa-by-jin40789108/