leetcode501. Find Mode in Binary Search Tree

501. Find Mode in Binary Search Tree

Given a binary search tree (BST) with duplicates, find all the mode(s) (the most frequently occurred element) in the given BST.

Assume a BST is defined as follows:

The left subtree of a node contains only nodes with keys less than or equal to the node’s key.
The right subtree of a node contains only nodes with keys greater than or equal to the node’s key.
Both the left and right subtrees must also be binary search trees.

For example:
Given BST [1,null,2,2],
   1
    \
     2
    /
   2
return [2].

Note: If a tree has more than one mode, you can return them in any order.

Follow up: Could you do that without using any extra space? (Assume that the implicit stack space incurred due to recursion does not count).

解法一

遍历结点（中序/后序/前序都可以），同时维护一个hashmap，存入每个结点的值出现的个数，求出最大值。再取出最大值对应的结点的值。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    Map<Integer, Integer> map = new HashMap<>();
    int max = 0;
    public int[] findMode(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if (root == null) {
            return new int[0];
        }
        inOrder(root);
        for (int key : map.keySet()) {
            if (map.get(key) == max) {
                list.add(key);
            }
        }
        int[] ret = new int[list.size()];
        for (int j = 0; j < list.size(); j++) {
            ret[j] = list.get(j);
        }
        return ret;
    }
    public void inOrder(TreeNode root) {
        List<Integer> ret = new ArrayList<>();
        if (root != null) {
            inOrder(root.left);
            if (map.containsKey(root.val)) {
                map.put(root.val, map.get(root.val) + 1);
            } else {
                map.put(root.val, 0);
            }
            max = Math.max(max, map.get(root.val));
            inOrder(root.right);
        }
    }
}

解法二

二叉搜索树中序遍历，是递增的，所以比较相邻结点的值是否相等，如果相等，count++，如果不等，count=1。再判断count是否大于max，如果大于更新max，更新list。如果相等，list添加该值。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    int max = 0;
    Integer pre = null;
    int count = 1;
    public int[] findMode(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if (root == null) {
            return new int[0];
        }
        inOrder(root, list);
        int[] ret = new int[list.size()];
        for (int j = 0; j < list.size(); j++) {
            ret[j] = list.get(j);
        }
        return ret;
    }
    public void inOrder(TreeNode root, List<Integer> list) {
        if (root == null) {
            return;
        }
        inOrder(root.left, list);
        if (pre != null) {
            if (root.val == pre) {
                count++;
            } else {
                count = 1;
            }
        }
        if (count > max) {
            max = count;
            list.clear();
            list.add(root.val);
        } else if (count == max) {
            list.add(root.val);
        }
        pre = root.val;
        inOrder(root.right, list);
    }
}

解法三

前面的两种解法用了map和list额外的空间复杂度，空间复杂度O（1）的做法是，进行两次dfs，第一次找到最大值的个数，然后开辟数组空间，第二次在数据空间中添加对应的值。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    int max = 0;
    Integer pre = null;
    int count = 1;
    int[] mode;
    int modCount;
    public int[] findMode(TreeNode root) {
        if (root == null) {
            return new int[0];
        }
        travelser(root);
        mode = new int[modCount];
        modCount = 0;
        count = 1;
        pre = null;
        travelser(root);
        return mode;
    }
    public void travelser(TreeNode root) {
        if (root == null) {
            return;
        }
        travelser(root.left);
        if (pre != null) {
            if (root.val == pre) {
                count++;
            } else {
                count = 1;
            }
        }
        if (count > max) {
            max = count;
            modCount = 1;
        } else if (count == max) {
            if (mode != null) {
                mode[modCount] = root.val;
            }
            modCount++;
        }
        pre = root.val;
        travelser(root.right);
    }
}