501. 二叉搜索树中的众数

给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有 众数（即，出现频率最高的元素）。

如果树中有不止一个众数，可以按 任意顺序 返回。

假定 BST 满足如下定义：

结点左子树中所含节点的值 小于等于 当前节点的值
结点右子树中所含节点的值 大于等于 当前节点的值
左子树和右子树都是二叉搜索树

提示：

树中节点的数目在范围 [1, 104] 内
-105 <= Node.val <= 105

题解

使用中序遍历+map存储

/**
 * 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 {
	
	 HashMap<Integer,Integer> map=new HashMap<Integer,Integer>();
	public  int[] findMode(TreeNode root) {
		backtrack(root);
		//将map的v降序排列
		//这里将map.entrySet()转换成list
		List<Map.Entry<Integer,Integer>> tmpList = new ArrayList<Map.Entry<Integer,Integer>>(map.entrySet());
		Collections.sort(tmpList, new Comparator<Map.Entry<Integer, Integer>>() {
			@Override
			public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
				return o2.getValue()-o1.getValue();
			}
		});

		ArrayList<Integer> list=new ArrayList<>();
		int count=-1;

		for (Map.Entry<Integer, Integer> entry : tmpList) {
			if(entry.getValue()>=count){
				list.add(entry.getKey());
				count=entry.getValue();
			}
		}

		int[] res=new int[list.size()];
		for (int i = 0; i < list.size(); i++) {
			res[i]=list.get(i);
		}

		return res;
	}

	public  void backtrack(TreeNode node){
		if(node==null) return;

		backtrack(node.left);
		//先判断是否已经存在
		map.put(node.val,map.getOrDefault(node.val,0)+1);
		backtrack(node.right);
	}
}

学到了map怎么按照value进行降序排列，害，自己好菜啊😭
map按照value降序排序：
1、将map转为list集合，之后对list集合进行排序就可以了

List<Map.Entry<Integer,Integer>> list=new ArrayList<Map.Entry<Integer,Integer>>(map.entrySet());

在力扣评论区看到的别人的题解：

二叉搜索树的中序遍历是递增顺序，把问题转换为求递增数组众数即可。

class Solution {
    int preVal = 0, curTimes = 0, maxTimes = 0;
    ArrayList<Integer> list = new ArrayList<Integer>();
    public int[] findMode(TreeNode root) {
	traversal(root);
	//list转换为int[]
	int size = list.size();
	int[] ans = new int[size];
	for(int i = 0; i < size; i++){
	    ans[i] = list.get(i);
	}
	return ans;
    }
    //二叉搜索树中序遍历是递增顺序
    public void traversal(TreeNode root){
	if(root != null){
	    traversal(root.left);
	    //判断当前值与上一个值的关系, 更新 curTimes 和 preVal
	    if(preVal == root.val){
		curTimes++;
	    }else{
		preVal = root.val;
		curTimes = 1;
	    }
	    //判断当前数量与最大数量的关系, 更新 list 和 maxTimes
	    if(curTimes == maxTimes){
		list.add(root.val);
	    }else if(curTimes > maxTimes){
		list.clear();
		list.add(root.val);
		maxTimes = curTimes;
	    }
	    traversal(root.right);
	}
    }
}

看到二叉搜索树就想这句话，不会的请背诵：

中序遍历二叉搜索树等于遍历有序数组