Day7 除自身以外数组的乘积 最小栈 二叉树的最近公共祖先

Posted 2022-11-30 未来可期-2018

除自身以外数组的乘积
本题利用left数组存储左连乘积，$left[i]={\prod }_{k=1}^{i}nums[k]$；
right数组存储右连乘积，$right[i]={\prod }_{k=i}^{n}nums[k]$；
则不包括nums[i]的乘积为$nums[i]=left[i-1]\ast right[i+1]$。复杂度为O(n)

class Solution(object):
    def productExceptSelf(self, nums):
        # left左累积，right右累积，ans[i]=left[i-1]*right[i+1]
        left=[1]*len(nums)
        left[0]=nums[0]
        for i in range(1,len(nums)):
            left[i]=left[i-1]*nums[i]
        right=[1]*len(nums)
        right[-1]=nums[-1]
        for i in range(len(nums)-2,-1,-1):
            right[i]=right[i+1]*nums[i]
        ans=[1]*len(nums)
        ans[0]=right[1]
        ans[-1]=left[-2]
        for i in range(1,len(nums)-1):
            ans[i]=left[i-1]*right[i+1]
        return ans

最小栈
最小栈，使用一个辅助栈存储栈的最小值，添加、删除、取顶、取最小元素,复杂度均为O(1)

class MinStack(object):
    # 最小栈，使用一个额外的栈保存最小元素
    def __init__(self):
        self.stack=[]
        self.minStack=[]

    def push(self, x):
        self.stack.append(x)
        if len(self.minStack)==0:
            self.minStack.append(x)
        else:
            self.minStack.append(min(x,self.minStack[-1]))
        
    def pop(self):
        if len(self.stack)>0:
            self.stack.pop(-1)
            self.minStack.pop(-1)


    def top(self):
        if len(self.stack)>0:
            return self.stack[-1]


    def getMin(self):
        if len(self.minStack)>0:
            return self.minStack[-1]

二叉树的最近公共祖先
本题较二叉搜索树的最近公共祖先难度稍大，二叉搜索树可以直接根据值判断向左子树扩展或者右子树扩展；
left为在root的左子树查找p和q的结果，right为在root的右子树查找p和q的结果；
如果left和right都不为空，那么p和q在root的两边，p和q的公共祖先必定为root；
如果left和right都为空，那么返回null；
如果left为空，right不为空，说明root的左子树找不到，要返回右子树；
如果left不为空，right为空，root右子树找不到，返回左子树；

# 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):
        if not root or root.val in [p.val,q.val]:
            return root
        left=self.lowestCommonAncestor(root.left, p, q)
        right=self.lowestCommonAncestor(root.right, p, q)
        if not left:
            return right
        if not right:
            return left
        # left和right都不为空，
        return root