LeetCode--501--easy--FindModeInBinarySearchTree

最新推荐文章于 2024-01-26 01:55:06 发布

微观尽头

最新推荐文章于 2024-01-26 01:55:06 发布

阅读量95

点赞数

分类专栏： LeetCode

本文链接：https://blog.csdn.net/huangdingsheng/article/details/103131423

版权

LeetCode 专栏收录该内容

199 篇文章 0 订阅

订阅专栏

这篇博客详细解析了如何解决LeetCode上的第501题，这是一道关于在二叉搜索树中查找出现次数最多的元素，即众数的问题。通过遍历二叉搜索树，博主分享了有效的解题思路和实现方法。

摘要由CSDN通过智能技术生成

package com.app.main.LeetCode.tree;

import com.app.main.LeetCode.base.TreeNode;

import java.util.ArrayList;
import java.util.List;

/**
 *
 * 501
 *
 * easy
 *
 * https://leetcode.com/problems/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).
 *
 *
 *
 * Created with IDEA
 * author:Dingsheng Huang
 * Date:2019/11/15
 * Time:下午8:53
 */
public class FindModeInBinarySearchTree {

    private TreeNode pre = null;

    private Integer max = 0;

    private Integer cn = 0;

    // mode 众数
    public int[] findMode(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        inorderTraversal(root, result);
        int[] res = new int[result.size()];
        for (int i = 0; i < result.size(); i++) {
            res[i] = result.get(i);
        }
        return res;

    }

    private void inorderTraversal(TreeNode curr, List<Integer> result) {
        if (curr != null) {
            if (curr.left != null) {
                inorderTraversal(curr.left, result);
            }
            // todo
            if (pre != null) {
                if (curr.val == pre.val) {
                    cn++;
                    if (cn == max) {
                        result.add(curr.val);
                    } else if (cn > max) {
                        result.clear();
                        result.add(curr.val);
                        max = cn;
                    }
                }  else {
                    cn = 1;
                    if (cn == max) {
                        result.add(curr.val);
                    }
                }
                pre = curr;

            } else {
                // init
                pre = curr;
                cn = 1;
                max = 1;
                result.add(curr.val);
            }

            if (curr.right != null) {
                inorderTraversal(curr.right, result);
            }
        }
    }
}