第八周算法作业

第八周算法作业 No.110,235,257

No.110平衡二叉树

• 思路

采用递归的方式：
1. 先判断以当前的节点左右子节点为根节点的树是否为平衡二叉树
2. 如果子节点的二叉树都为平衡二叉树，则判断以当前节点为根节点的树是否为平衡二叉树
3. 依次自底向上回推即可判断整棵树是否为平衡二叉树

• 代码

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def getDepth(self, root):
        if root ==None:
            return 0
        return max(self.getDepth(root.left), self.getDepth(root.right))+1
    def isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if root==None:
            return True
        if self.isBalanced(root.left) and self.isBalanced(root.right):
            if abs(self.getDepth(root.left)-self.getDepth(root.right))>1:
                return False
            else:
                return True
        else:
            return False

• 作业截图
  

No.235二叉搜索树的最近公共祖先

• 思路

本题做完之后发现忘记了树是二叉搜索树，，
如果是二叉搜索树，则比较简单，如下：
1. 我们从根节点开始遍历；
2. 如果当前节点的值大于 pp 和 qq 的值，说明 pp 和 qq 应该在当前节点的左子树，因此将当前节点移动到它的左子节点；
3. 如果当前节点的值小于 pp 和 qq 的值，说明 pp 和 qq 应该在当前节点的右子树，因此将当前节点移动到它的右子节点；
4. 如果当前节点的值不满足上述两条要求，那么说明当前节点就是「分岔点」。此时，pp 和 qq 要么在当前节点的不同的子树中，要么其中一个就是当前节点。

如果不是二叉搜索树的话，则需要利用后序遍历，自底向上遍历，记录p和q节点是否曾经出现过，如果两个节点都出现过，则当前的节点为所求节点。

• 代码

# 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 lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        # 自底向上
        if root==None:
            return None
        root1 = self.lowestCommonAncestor(root.left, p, q)
        root2 = self.lowestCommonAncestor(root.right, p, q)
        if root1!=None:
            return root1
        if root2!=None:
            return root2
        p_exist, q_exist = self.checkPQexist(root, p, q)
        #print(root.val, p_exist, q_exist)
        if p_exist==True and q_exist==True:
            return root
    
    def checkPQexist(self, root, p, q):
        # 检查p和q是否在以root为根节点的树中出现过
        # 返回p, q是否存在
        if root==None:
            return False,False
        p_left, q_left = self.checkPQexist(root.left, p, q)
        p_right, q_right = self.checkPQexist(root.right, p, q)
        p_exist = p_left or p_right
        q_exist = q_left or q_right
        if root.val==p.val:
            p_exist=True
        if root.val==q.val:
            q_exist=True
        return p_exist, q_exist

• 作业截图
  

No.257 二叉树的所有路径

• 思路

后序遍历，先找到以左右节点为根节点的所有路径，然后合并
在这些路径中加入当前的节点，返回到上一层

• 代码

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def binaryTreePaths(self, root):
        """
        :type root: TreeNode
        :rtype: List[str]
        """
        if root==None:
            return []
        left_list = self.binaryTreePaths(root.left)
        right_list = self.binaryTreePaths(root.right)
        if len(left_list)==0 and len(right_list)==0:
            return [str(root.val)]

        if len(right_list)!=0:
            # 右节点有值
            for i in range(len(right_list)):
                right_list[i] = str(root.val) + '->' + right_list[i]

        if len(left_list)!=0:
            # 左节点有值
            for i in range(len(left_list)):
                left_list[i] = str(root.val) + '->' + left_list[i]

        final_list = []
        # 合并左右路径
        
        for i in range(len(left_list)):
            final_list.append(left_list[i])
        for i in range(len(right_list)):
            final_list.append(right_list[i])
        return final_list

• 作业截图