LeetCode 501二叉搜索树中的众数

给定一个有相同值的二叉搜索树（BST），找出 BST 中的所有众数（出现频率最高的元素）。

假定 BST 有如下定义：

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

例如：
给定 BST [1,null,2,2],

   1
    \
     2
    /
   2

返回[2].

提示：如果众数超过1个，不需考虑输出顺序

进阶：你可以不使用额外的空间吗？（假设由递归产生的隐式调用栈的开销不被计算在内）

 

package tiku;

import java.util.*;

/**
 * className Q501
 * description TODO
 *
 * https://leetcode-cn.com/problems/find-mode-in-binary-search-tree/
 *
 * @author ln
 * @version 1.0
 * @date 2019/5/19 12:08
 */
public class Q501 {

    /**
     * Definition for a binary tree node.
     * public class TreeNode {
     *     int val;
     *     TreeNode left;
     *     TreeNode right;
     *     TreeNode(int x) { val = x; }
     * }
     */
    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode(int x) { val = x; }
     }
    class Solution {
        Map<Integer, Integer> map = new HashMap<>();
        public int[] findMode(TreeNode root) {

            if (root == null){
                return new int[0];
            }
            int[] ans = new int[100000];
            int i = 0;
            preOrder(root);
            Object maxValue = getMaxValue(map);
            for (Map.Entry<Integer, Integer> entry : map.entrySet()){
                if (maxValue.equals(entry.getValue())) {
                    ans[i] = entry.getKey();
                    i++;
                }
            }
            int count = 0;
            for (int j = 0; j < ans.length; j++){
                if (ans[j] != 0){
                    count++;
                }
            }
            if (ans[0] == 0){
                count++;
            }
            int[] res = new int[count];
            for (int j = 0; j < count; j++){
                res[j] = ans[j];
            }
            return res;
        }

        /**
         * 遍历树并把每个数出现的次数记录到map中，类似桶排序
         * @param root
         */
        private void preOrder(TreeNode root){
            if (root == null) {
                return;
            }
            if (map.containsKey(root.val)){
                map.put(root.val, map.get(root.val) + 1);
            } else {
                map.put(root.val, 1);
            }
            preOrder(root.left);
            preOrder(root.right);
        }

        /**
         * 获取出现最多的次数
         * @param map
         * @return
         */
        private Object getMaxValue(Map<Integer, Integer> map){

            if (map.size() == 0){
                return null;
            }

            Collection<Integer> c = map.values();
            Object[] objects = c.toArray();
            Arrays.sort(objects);
            return objects[objects.length - 1];
        }
    }
}