GaryLeetCode学习笔记·伍（第十四周）

101. 对称二叉树

给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

1

/
2 2
/ \ /
3 4 4 3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

1

/
2 2
\
3 3
说明:

如果你可以运用递归和迭代两种方法解决这个问题，会很加分。

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

class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        def f(l,r):
            if not l:
                return not r
            if not r:
                return not l
            if l.val==r.val:
                return f(l.left,r.right) and f(l.right,r.left)
            else:
                return False
        if not root:
            return True
        else:
            return f(root.left,root.right)

定义判断局部是否对称的函数：若左支点为空，则返回右支点的bool；若右支点为空，则返回左支点的bool；若左支点和右支点的值相同，则判断下一级结点的左右支点的情况（递归）。调用函数，以头结点的左右结点开始递归。

104. 二叉树的最大深度

给定一个二叉树，找出其最大深度。

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

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

3

/
9 20
/
15 7
返回它的最大深度 3 。

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

class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        else:
            l=1+self.maxDepth(root.left)
            r=1+self.maxDepth(root.right)
            return max(l,r)

将整个二叉树分为左右两个部分，分别递归，每递一次便深度加一，直到root为空时结束，初始因为原始节点的存在还要加一。

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

将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。

本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

示例:

给定有序数组: [-10,-3,0,5,9],

一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树：

  0
 / \

-3 9
/ /
-10 5

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
 
class Solution(object):
    def sortedArrayToBST(self, nums):
        """
        :type nums: List[int]
        :rtype: TreeNode
        """
        if not nums:
            return None
        mid=len(nums)//2#找到中间节点对应的index
        root=TreeNode(nums[mid])#当前节点为根节点
        root.left=self.sortedArrayToBST(nums[:mid])#小于当前根节点的作为左子树
        root.right=self.sortedArrayToBST(nums[mid+1:])#大于当前根节点的作为右子树
        return root

先取出数组中间位置的值作为二叉查找树的根结点，然后以该数组中间位置的值为中心，将左边的数组划分到根结点的左子树中，右边的数组划分到根结点的右子树中，这样就能满足二叉搜索树的定义。接下来，使用递归地方法继续取出左边数组的中间值作为根结点的左子结点，右边数组的中间值作为根结点的右子结点，然后以左边数组中间值为中心，再次划分左右子树，右边数组同理，如此递归下去，对于每个结点，总是能保证其左子树上任意结点的值都要小于该节点的值，其右子树上任意结点的值都要大于该节点的值

新概念： 二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。

110. 平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

3

/
9 20
/
15 7
返回 true 。

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

   1
  / \
 2   2
/ \

3 3
/
4 4
返回 false 。

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

class Solution(object):
    def isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        def maxDepth(self, root):
            l=1+self.maxDepth(root.left)
            r=1+self.maxDepth(root.right)
            return max(l,r)
    if not root:
        return True
    elif -1<=self.maxDepth(root.left)-self.maxDepth(root.right)<=1:
        return self.isBalanced(root.left) and self.isBalanced(root.right)
    else:
        return False

本题是第一次试着应用递归法，但不出意料的出现了错误。我的思路是，调用104题定义的深度函数，然后比较每个结点左右两个子树的深度即可，求解。
错误提示为：

Line 19: SyntaxError: ‘return’ outside function

网上的另一种解法，与我思路大体相同，也是定义了高度函数

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

class Solution(object):
    def isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
   
        if root == None:
            return True
        elif abs(self.height(root.left)-self.height(root.right))>1:
            return False
        else:
            return self.isBalanced(root.left) and self.isBalanced(root.right)
    
    def height(self,root):
        if root == None:
            return 0
        else:
            return max(self.height(root.left),self.height(root.right))+1