56、★★BST-LeetCode-501.二叉搜索树中的众数-不像简单题的简单题

题目描述：

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

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

假定 BST 满足如下定义：

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

来源：力扣（LeetCode）

思路：

1）本题主要就是实现BST的中序遍历；记得添加一个前驱节点比较方便，类似Morris算法！

有返回值写法：

无返回值写法：

2）这道题，难处理的是对最大频数的记录；

用map难处理；使用update，进行随时更新

3）Morris算法！！！

注意前驱节点的妙用！！！

左子树的内容都会成为某一个节点的前驱节点！！！

代码：

用map没处理出来的错误写法

class Solution {
    //之前验证BST，递归方法返回boolean，有一种BST的递归写法
    //计算最小绝对差，无返回值，又一种void的写法！要记住

    List<Integer> res = new ArrayList<>();
    Map<Integer,Integer> map = new HashMap<>();
    int index = 1;
    TreeNode pre;//记录中序遍历中的，前一个节点
    public int[] findMode(TreeNode root) {
        fre(root);
        int[] ret = new int[res.size()];
        //对Map中的数值进行排序处理，无法完成！
    }
    //要记住上一个的数值，中序遍历
    void fre(TreeNode root){
        if(root == null) return;
        //前序：这一步可以走到最左
        fre(root.left);
        //中序
        if(pre != null){
            if(root.val == pre.val){
                index++;
            }else{
                map.put(index,root.val);
                index = 1;
            }
        }
        pre = root;
        //后序的步骤
        fre(root.right);
    }
}

1）递归：感觉递归的空间复杂度就是 O(N)，因为每次都要开辟新的栈！

class Solution {

    List<Integer> res = new ArrayList<>();
    int index = 1;
    int maxCount = 1;//记录最大
    TreeNode pre;//记录中序遍历中的，前一个节点
    public int[] findMode(TreeNode root) {
        fre(root);
        int[] ret = new int[res.size()];
        for(int i = 0;i < res.size();i++){
            ret[i] = res.get(i);
        }
        return ret;
    }
   void fre(TreeNode root){
       if(root == null) return;

       //前
       fre(root.left);

       //中，处理当前节点
       //主要的代码逻辑在这儿实现
       if(pre == null || pre.val != root.val){
           index = 1;//此时开始新的节点，设置为1
       }else{
           index++;
       }

       //index不能重置
       if(index > maxCount){
           //之前链表中的不再是最大频数内容
           res.clear();
           res.add(root.val);
           maxCount = index;//重置最大频数
       }else if(index == maxCount){
           res.add(root.val);//是最大频数，就加进去
       }

       //更新前去节点为当前节点！
       pre = root;

       //后
       fre(root.right);

   }
}

2）迭代：迭代不使用额外的栈结构时，空间复杂度为O(1)

class Solution {

    //中序遍历的Morris算法!
    //有两个处理当前节点的情况
    List<Integer> res = new ArrayList<>();
    int index = 0;
    int maxCount = 0;
    int preVal;
    TreeNode pre;
    public int[] findMode(TreeNode root) {
        TreeNode cur = root;
        while(cur != null){
            if(cur.left == null){
                update(cur.val);
                cur = cur.right;//当前节点处理结束，往右节点走！
                //什么意思？
                continue;
            }
            //左子树不为空，去左子树的最右节点，也就是遍历cur的前一个节点，也就是前驱节点
            pre = cur.left;//向左走；
            while(pre.right != null && pre.right != cur){
                pre = pre.right;
            }
            if(pre.right == null){
                pre.right = cur;
                cur = cur.left;
            }else{//此时要遍历该点
                pre.right =null;// 先置空
                //处理当前节点
                update(cur.val);
                cur = cur.right;
            }
        }
        int[] ret = new int[res.size()];
        for(int i = 0;i < res.size();i++){
            ret[i] = res.get(i);
        }
        return ret;
    }
    //更新结果列表的方法
    void update(int val){
        if(val == preVal){
            index++;
        }else{
            index = 1;
            preVal = val;
        }

        if(index == maxCount){
            res.add(val);
        }
        if(index > maxCount){
            maxCount = index;
            res.clear();
            res.add(val);
        }
    }
}