补题| 大脑康复训练

最深公共父节点

递归写法

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        
        def dfs(root,p,q):
            if(root == None):
                return None
            if(root.val == p.val or root.val == q.val):
                return root
            lson = dfs(root.left,p,q)
            rson = dfs(root.right,p,q)
            if(lson == None):
                return rson
            elif(rson == None):
                return lson
            else:
                return root
        
        return dfs(root,p,q)

非递归写法

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        values = []
        val2node = {}
        def dfs(root):
            if(root.left!=None):
                val2node[root.left.val] = root
                dfs(root.left)
            if(root.right!=None):
                val2node[root.right.val] = root
                dfs(root.right)
        dfs(root)
        visited = set()
        val2node[root.val] = None
        while p!=None:
            visited.add(p.val)
            p = val2node[p.val]
        while q!=None:
            if(q.val in visited):
                return q
            q = val2node[q.val]
        return None

   继续再做一遍

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

#
# 
# @param root TreeNode类 
# @param o1 int整型 
# @param o2 int整型 
# @return int整型
#
class Solution:
    def __init__(self):
             self.ans = -1
    def dfs(self,head,o1,o2):
            if(head == None):
                return False
            lson = self.dfs(head.left,o1,o2)
            rson = self.dfs(head.right,o1,o2)
            if  (lson and rson) or ((lson or rson) and (head.val == o1 or head.val == o2)) :
                self.ans = head.val
            else:
                return lson or rson or (head.val == o1 or head.val == o2)
            
    def lowestCommonAncestor(self , root , o1 , o2 ):
        # write code here
        '''
        func1
        self.dfs(root,o1,o2)
        return self.ans
        '''
        '''
        func2
        def dfs(root,o1,o2):
            if(root == None):
                return None
            if(root.val == o1 or root.val==o2):
                return root
            lson = dfs(root.left,o1,o2)
            rson = dfs(root.right,o1,o2)
            if(lson !=None and rson !=None):
                return root
            elif lson !=None:
                return lson
            else:
                return rson
        ans = dfs(root,o1,o2)
        return ans.val 
        '''
        '''
        func3
        val2node = {}
        def dfs(head,o1,o2):
            if(head == None):
                return
            if(head.left!=None):
                val2node[head.left.val] = head.val
                dfs(head.left,o1,o2)
            if(head.right!=None):
                val2node[head.right.val] = head.val
                dfs(head.right,o1,o2)
        dfs(root, o1, o2)
        val2node[root.val] = None
        visited = set()
        o1_father = val2node[o1]
        visited.add(o1)
        while o1_father!=None:
            visited.add(o1_father)
            o1_father = val2node[o1_father]
        o2_father = val2node[o2]
        if o2 in visited:
                #visited2.add(o2_father)
                return o2
        while o2_father!=None:
            if o2_father in visited:
                #visited2.add(o2_father)
                return o2_father
            o2_father = val2node[o2_father]

        '''

upper bound

class Solution:
    def search(self , nums , target ):
        # write code here
        l , r = 0, len(nums)-1
        ans = -1
        while l<=r:
            mid = l + (r-l)//2
            if target == nums[mid]:
                ans = mid
                r = mid -1
            elif(target > nums[mid]):
                l = mid + 1
            else:
                r = mid - 1
        return ans