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

LeetCode 530. 二叉搜索树的最小绝对差
题目链接：530. 二叉搜索树的最小绝对差 - 力扣（LeetCode）

​思路：

一开始我以为两个点要有父子关系，也就是相连，所以做错了。正确的做法是初始化一个res来存最小的差值，然后递归来计算。

代码：

#python  写错了的版本
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        def helper(node):
            if node.left:
                self.res = min(self.res, node.val - node.left.val)
                helper(node.left)
            if node.right:
                self.res = min(self.res, node.right.val - node.val)
                helper(node.right)
        helper(root)
        return self.res

    def __init__(self):
        self.res = float('inf')

#python 正确版本  我们注意一直比对一个最小的self.res就好
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        self.traversal(root)
        return self.res

    def __init__(self):
        self.res = float('inf')
        self.pre = None
    
    def traversal(self, cur):
        if not cur:
            return
        self.traversal(cur.left)
        if self.pre:
            self.res = min(self.res, cur.val - self.pre.val)
        self.pre = cur
        self.traversal(cur.right)

/java
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int getMinimumDifference(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if(root == null){
            return 0;
        }
        traversal(root, list);
        int[] arr = new int[list.size()];
        int index = 0;
        for(int i : list){
            arr[index++] = i;
        }
        Arrays.sort(arr);
        int min_diff = Integer.MAX_VALUE;
        for(int i = 0; i < arr.length - 1; i++){
            if(Math.abs(arr[i + 1] - arr[i]) < min_diff){
                min_diff = Math.abs(arr[i + 1] - arr[i]);
            }
        }
        return min_diff;
    }

    private void traversal(TreeNode root, List<Integer> list){
        list.add(root.val);
        if(root.left == null && root.right == null){
            return;
        }
        if(root.left != null){
            traversal(root.left, list);
        }
        if(root.right != null){
            traversal(root.right, list);
        }
    }
}

---

LeetCode 501. 二叉搜索树中的众数
题目链接：501. 二叉搜索树中的众数 - 力扣（LeetCode）

​思路：

朴素的想法：使用一个hashmap来存出现的元素及其频次，然后对hashmap进行排序，取一个最大的输入res中，遍历一下hashmap，如果有频次与第一个相同的，则也是满足结果要求的众数，我们也要把其键值也就是该数放入res中。

代码：

#python  
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        def helper(node):
            if not node:
                return
            self.hashmap[node.val] = self.hashmap.get(node.val, 0) + 1
            helper(node.left)
            helper(node.right)

        helper(root)
        sorted_hashmap = sorted(self.hashmap.items(), key=lambda x: x[1], reverse=True)
        max_count = sorted_hashmap[0][1]
        res = []
        for key, count in sorted_hashmap:
            if count == max_count:
                res.append(key)
            else:
                break
        return res

    def __init__(self):
        self.res = []
        self.hashmap = {}

/java
import java.util.*;

class Solution {
    public int[] findMode(TreeNode root) {
        Map<Integer, Integer> map = new HashMap<>();
        traversal(root, map);
        
        // 找到出现次数最多的值
        int maxCount = 0;
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            maxCount = Math.max(maxCount, entry.getValue());
        }
        
        // 创建一个列表来存储众数
        List<Integer> modes = new ArrayList<>();
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            if (entry.getValue() == maxCount) {
                modes.add(entry.getKey());
            }
        }
        
        // 将列表转换为数组并返回
        return modes.stream().mapToInt(Integer::intValue).toArray();
    }

    private void traversal(TreeNode node, Map<Integer, Integer> map) {
        if (node == null) {
            return;
        }
        // 更新map中的计数
        map.put(node.val, map.getOrDefault(node.val, 0) + 1);
        
        // 递归遍历左右子树
        traversal(node.left, map);
        traversal(node.right, map);
    }
}

---

LeetCode 236.  二叉树的最近公共祖先
题目链接：236. 二叉树的最近公共祖先 - 力扣（LeetCode）

​思路：

递归再递归。

代码：

#python
class Solution:
    def lowestCommonAncestor(self, root, p, q):
        if root == q or root == p or root is None:
            return root

        left = self.lowestCommonAncestor(root.left, p, q)
        right = self.lowestCommonAncestor(root.right, p, q)

        if left is not None and right is not None:
            return root

        if left is None and right is not None:
            return right
        elif left is not None and right is None:
            return left
        else: 
            return None

/java
public class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null || root == p || root == q) {
            return root;
        }
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        if (left != null && right != null) {
            return root; // p 和 q 分别在左右子树中
        }
        return left != null ? left : right; // p 和 q 都在同一侧的子树中
    }
}

---