力扣刷题 day08:09-07

1.对称二叉树

给你一个二叉树的根节点 root ， 检查它是否轴对称。

 方法一：递归法

#方法一：递归法
def isSymmetric(root):
    if root==None:
        return True
    return check(root.left,root.right)
def check(left,right):
    if (left==None and right!=None) or (left!=None and right==None):
        return False              #递归终止条件，一个为空一个不为；两个都为空；两个节点的值不相等
    if left==None and right==None:  
        return True
    if left.val !=right.val:
        return False                                               #右子树的左节点等于左子树的右节点
    return check(left.left,right.right) and check(left.right,right.left) #左子树的左节点等于右子树的右节点

方法二：循环迭代法

#方法二：循环迭代法
def isSymmetric(root):
    if root==None:
        return True       #若树为空则返回true
    if root.left==None and root.right==None:
        return True           #若树的左子树合右子树为空返回true
    quene=[(root.left,root.right)]     #初始化队列
    while quene:
        left,right=quene.pop(0) #先进先出
        if left==None and right==None:
            continue     #两个节点都为空，继续循环
        if left==None or right==None:   #一个为空另一个不为空返回false
            return False
        if left.val !=right.val:      #左右节点值不相等
            return False
        quene.append((left.left,right.right))  #右子树的左节点等于左子树的右节点
        quene.append((left.right,right.left)) #左子树的左节点等于右子树的右节点
    return True

 2.二叉树的最大深度

给定一个二叉树 root ，返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

方法一：后序遍历，利用递归 

#方法一：后序遍历，利用递归
def maxDepth(root):
    if not root:
        return 0      #没有根节点
    return max(maxDepth(root.left),maxDepth(root.right))+1  #左右子树最深层加一

方法二：层序遍历，利用队列 

#方法二：层序遍历，利用队列
def maxDepth(root):
    if not root:
        return 0     #没有根节点
    queue,res=[root],0       #queue队列用于储存节点，res记录层数
    while queue:
        tem=[]     #临时储存下一层的节点
        for q in queue:
            if q.left :
                tem.append(q.left)
            if q.right:
                tem.append(q.right) #放入tem中进行储存
        queue=tem     #更新队列
        res+=1
    return res

3.有序数组转换为二叉搜索树

给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。

高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

 方法一：递归

#方法一：递归
def sortedArrayToBST(nums):
    if len(nums)==0:
        return 
    elif len(nums)==1:
        return TreeNode(nums[0])  #只有一个根节点
    #对半分
    mid=len(nums)//2
    node=TreeNode(nums[mid])    #获取对应的根节点
    node.left=sortedArrayToBST(nums[:mid])
    node.right=sortedArrayToBST(nums[mid+1:])  #分成左右子树
    return node