代码随想录算法训练营第二十一天| LeetCode530.二叉搜索树的最小绝对差、LeetCode501.二叉搜索树中的众数、LeetCode236. 二叉树的最近公共祖先

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

题目描述: 530.二叉搜索树的最小绝对差.

解法

递归(数组)

class Solution(object):
    def travel(self,root):
        if not root:
            return []
        left = self.travel(root.left)
        right = self.travel(root.right)
        return left + [root.val] + right

    def getMinimumDifference(self, root):
        vals = self.travel(root)
        min = float("inf")
        for i in range(1,len(vals)):
            if vals[i] - vals[i-1] < min:
                min = vals[i] - vals[i-1]
        return min

递归（指针）

class Solution(object):
    def __init__(self):
        self.min = float('inf')
        self.pre = None

    def travel(self,root):
        if not root:
            return 
        left = self.travel(root.left)
        if self.pre:
            self.min = min(self.min,root.val - self.pre.val)
        self.pre = root
        right = self.travel(root.right)

    def getMinimumDifference(self, root):
        self.travel(root)
        return self.min

如果在递归里想用指针的话，需要将一些值放在递归之外。

迭代

lass Solution(object):
    def getMinimumDifference(self, root):
        min_abs = float('inf')
        st = [root]
        pre = None
        while st:
            node = st.pop()
            if node:
                if node.right:
                    st.append(node.right)
                st.append(node)
                st.append(None)
                if node.left:
                    st.append(node.left)
            else:
                node = st.pop()
                if pre:
                    min_abs = min(min_abs,node.val-pre.val)
                pre = node
        return min_abs

501.二叉搜索树中的众数

题目描述: 530.二叉搜索树的最小绝对差.

解法

递归(字典数组)

class Solution(object):
    def __init__(self):
        self.map = collections.defaultdict(int)
    
    def travel(self,node):
        if not node:
            return
        self.travel(node.left)
        self.map[node.val] += 1
        self.travel(node.right)
        
    def findMode(self, root):
        if not root:
            return []
        res = []
        self.travel(root)
        max_num = max(self.map.values())
        for k,v in self.map.items():
            if v == max_num:
                res.append(k)
        return res

递归双指针

class Solution(object):
    def __init__(self):
        self.max_count = 0
        self.count = 0
        self.pre = None
        self.res = []
    
    def travel(self,node):
        if not node:
            return
        self.travel(node.left)
        if not self.pre:    # 第一个节点
            self.res.append(node.val)   # 直接将当前节点加入到res
            self.count += 1 # 当前计数+1
            self.max_count+=1   # 最大计数+1
        else:   # 非第一个节点
            if self.pre.val != node.val:    # 与前一个结点不同
                self.count = 1  # 重新计算当前计数
            else:   # 与前一个结点不同
                self.count += 1 # 当前计数+1
            if self.count == self.max_count:    # 当前计数达到最大计数
                self.res.append(node.val)   # 在结果中加入当前计数对应的数字
            if self.count > self.max_count: # 当前计数超过最大计数
                self.max_count = self.count # 更新最大计数
                self.res = [node.val]   # 清空并赋值
        self.pre = node
        self.travel(node.right)
        
    def findMode(self, root):
        self.travel(root)
        return self.res

迭代

class Solution(object):
    def findMode(self, root):
        res = []
        st = [root]
        pre = None
        max_count = 0
        count = 0
        while st:
            node = st.pop()
            if node:
                if node.right:
                    st.append(node.right)
                st.append(node)
                st.append(None)
                if node.left:
                    st.append(node.left)
            else:
                node = st.pop()
                if not pre or node.val != pre.val:
                    count = 1
                else:
                    count += 1
                if count == max_count:
                    res.append(node.val)
                if count > max_count:
                    max_count = count
                    res = [node.val]
                pre = node
        return res    

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

题目描述: 530.二叉搜索树的最小绝对差.

解法

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        if root == p or root == q or not root:
            return root
        right = self.lowestCommonAncestor(root.right,p,q)
        left = self.lowestCommonAncestor(root.left,p,q)
        if left and right:
            return root
        if not left and right:
            return right
        elif left and not right:
            return left
        else:
            return None

判断每一颗树就好，首先判断它自身，如果它是q或者是p，那么直接返回他就好，如果这个节点和另一个节点不在一个分支上，那就作为left或者right条件，如果他是另一个节点的父节点，最后也会返回到结果中。
接下来就要判断它的左右子树了，如果左右子树都分别返回了内容（这个内容是不可能重复的，因为p和q都只有一个），那这个节点就是要返回的内容，最终一直到根节点，根节点的另一边没有返回内容，所以最后返回的是这个节点。
如果左右只有一个，那返回有的那个即可。
左右都没有的话，就返回None。