Day 21 代码随想录

---

530. 二叉搜索树的最小绝对差

二叉搜索树的最小绝对差

  这题很简单，二叉搜索树是有序的，所以就是直接计算两两之和即可。一开始以为不计算头结点，后来发现不需要排除头结点。

class Solution:
    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        result=[]
        def traveral(root):
            if not root:
                return
            traveral(root.left)
            result.append(root.val)
            traveral(root.right)
        # 计算头结点
        # def get_first(root):
        #     res=10
        #     if not root:
        #         return
        #     que=[root]
        #     while que:
        #         cur=que.pop()
        #         res=cur.val
        #     return res
        traveral(root)
        # first=get_first(root)
        # result.remove(first)
        left=0
        right=1
        Result=[]
        while right<len(result):
            Min=result[right]-result[left]
            Result.append(Min)
            left+=1
            right+=1
        return min(Result)

统计有序数组还可以这么写

for i in range(len(res)-1):  // 统计有序数组的最小差值
    r = min(abs(res[i]-res[i+1]),r)

501. 二叉搜索树中的众数

二叉搜索树中的众数

class Solution:
    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return 
        from collections import Counter
        result=[]
        def traveral(root):
            if not root:
                return None
            traveral(root.left)
            result.append(root.val)
            traveral(root.right)
        traveral(root)
        b=Counter(result)
        temp=max(b.values())
        res=[]
        res_value=[]
        res_key=[]
        for value in  b.values():
            res_value.append(value)
        for key in b.keys():
            res_key.append(key)
        for i in range(len(res_value)):
            if res_value[i] ==temp:
                res.append(res_key[i])
        return res

  寻找众数写的比较久，因为字典不可以迭代，所以转化为数字寻找。有很多都是众数的情况，需要单独讨论。

236. 二叉树的最近公共祖先

二叉树的最近公共祖先

  这里p和q传进来的都是树节点。

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if not root or p==root or  q==root:
            return root
        left=self.lowestCommonAncestor(root.left,p,q)
        right=self.lowestCommonAncestor(root.right,p,q)
        if left and right:
            return root
        if left==None and right!=None:
            return right
        if left!=None and right==None:
            return left
        return None