如何在Java中返回BinaryTree中最频繁的元素

我想返回BinaryTree中最常用的值的数量。我有一个BinaryClass，它包含许多方法，如add、contain、isEmpty、counter、iterator和其他。我试图实现这个方法

public int getMaxFrequency（）

，但在markerd行遇到了StackOverFlowException问题

当我运行我的代码时，我得到堆栈溢出异常，任何人都可以帮助我

我是BinaryTree的新手

请帮帮我

enter code here
public class TreeSetCounter<T extends Comparable<T>> implements    Iterable<T>{
public Node<T> root; 
int size;
int count=0;

public TreeSetCounter() {
    root = null;
    size = 0;
   }
 public int counter(T t) {
 return counterRecursive(root, t);
  }

   public int counterRecursive(Node<T> root, T t) {
   int count = 0;
   if(root == null) {
        return 0;
          }
    if(root.value.equals(t)) {
      count++; 
      }
   count = count + counterRecursive(root.left, t)+           counterRecursive(root.right, t);
   return count; }


 public int getMaxFrequency(){
 
  return inorder(root);           
  }

  public int inorder( Node<T> prev) {
 
    int count = 1, max = 0;
    if (root == null) {
        return 0;}
    List<T> list = new ArrayList<>();
    inorder(root.left);   // I get the Exception att this row code.
    while (prev != null) {
    if (root.value == prev.value)
            count++;
        else
            count = 1;
    }
    
    if (count > max) {
        max = count;
        list.clear();
        list.add(root.value);
    } else if (count == max) {
        list.add(root.value);
    }
    prev = root;
    inorder(root.right);
    return max;
}

enter code here
Node.java
public class Node <T>{
T value;
int counter;
Node<T> left;
Node<T> right;

Node(T value, int count) {
    this.value = value;
    right = null;
    left = null;
    this.counter= count;
    }

enter code here
public static void main(String[] args) {
    TreeSetCounter <String> tsc= new TreeSetCounter<String>();
    tsc.add("java");
    tsc.add("java");
    tsc.add("not");
    tsc.add("cool");
    tsc.add("java");
    tsc.add("is");
    tsc.add("java");
    tsc.add("good");
    System.out.println(tsc.getMaxFrequency());}

在此处输入代码
公共类TreeSetCounter实现Iterable{
公共节点根；
整数大小；
整数计数=0；
公共树计数器（）{
root=null；
尺寸=0；
}
公共整数计数器（T）{
返回反递归（根，t）；
}
公共int反递归（节点根，T）{
整数计数=0；
if（root==null）{
返回0；
}
if（根值等于（t））{
计数++；
}
计数=计数+反递归（root.left，t）+反递归（root.right，t）；
返回计数；}
public int getMaxFrequency（）{
按顺序返回（根）；
}
公共整数索引（节点上一个）{
整数计数=1，最大值=0；
if（root==null）{
返回0；}
列表=新的ArrayList（）；
inorder（root.left）；//我得到了此行代码的异常。
while（prev！=null）{
if（root.value==prev.value）
计数++；
其他的
计数=1；
}
如果（计数>最大值）{
最大值=计数；
list.clear（）；
list.add（root.value）；
}否则如果（计数==最大值）{
list.add（root.value）；
}
prev=根；
顺序（root.right）；
返回最大值；
}
在这里输入代码
Node.java
公共类节点{
T值；
整数计数器；
左淋巴结；
节点权；
节点（T值，整数计数）{
这个值=值；
右=空；
左=空；
这个计数器=计数；
}
在这里输入代码
公共静态void main（字符串[]args）{
TreeSetCounter tsc=新的TreeSetCounter（）；
添加（“java”）；
添加（“java”）；
tsc.添加（“非”）；
tsc.添加（“酷”）；
添加（“java”）；
tsc.添加（“is”）；
添加（“java”）；
tsc.添加（“良好”）；
System.out.println（tsc.getMaxFrequency（））；}

为计数器功能尝试以下方法：

public int counter (T t) {
  if (root == null) return 0;
  
  int count = 0;
  if (root.value.equals(t))
    count++;
  
  count += counterRecursive(root.left, t);
  count += counterRecursive(root.right, t);

  return count;
}

public int counterRecursive (Node<T> root, T t) {
   if (root == null) return 0;
   
   if (root.value.equals(t))
    return 1 + counterRecursive(root.left, t) + counterRecursive(root.right, t);
   else
    return counterRecursive(root.left, t) + counterRecursive(root.right, t);
}

这将有助于调试

顺序
和
getMaxFrequency
。我将在
getMaxFrequency
中使用
计数器
，同时查看其余部分。一般来说，使用
哈希映射
或
哈希表
更适合跟踪计数

试着这样做：

public int getMaxFrequency（）{
if（root==null）返回0；
HashMap计数=新建HashMap（）；
int count=计数器（根值）；
counts.put（root.value，count）；
//遍历树并获取计数
int left=getMaxFrequencyHelper（root.left，counts，count）；
int right=getMaxFrequencyHelper（root.right，counts，count）；
返回左>右？左：右；
}
私有int getMaxFrequencyHelper（节点节点，HashMap计数，最大值）{
如果（node==null）返回max；
如果（！counts.containsKey（node.value））
counts.put（node.value，计数器（node.value））；
int _max=counts.get（node.value）>max？counts.get（node.value）：max；
int left=getMaxFrequencyHelper（node.left，counts，_max）；
int right=getMaxFrequencyHelper（node.right，counts，_max）；
返回左>右？左：右；
}

这种技术被称为
memorization
，其中先前的计数被
缓存在
HashMap
中。看起来您缺少了一些步骤。是否有特定的
类应该
扩展
？我有一个包含很多方法的类Binarytree（add、size、isEmpty、counter和getMaxFrequency（）），在getMaxFrequency（）中，我必须返回在我的测试二叉树中最频繁的值的数目，我也有Node类。我的所有方法都可以正常工作，但对于getMaxFrequency（）。对于我的测试代码，getMaxFrequency（）应该为“java”返回4我有二进制树和节点类，getMaxFrequency（）应该在包含很多课程的BinaryTree课程。好的，我正在阅读你的代码。我会马上发布一个响应。谢谢你的帮助！谢谢，你的工作方式很好，我在等待GETMax频率。它是区分大小写的吗？如果不是，考虑把所有的东西都添加到大树中。这是SQL的标准，但是你也可以使用小写。不，树不区分大小写，如果你指的是方法名或变量名，它不区分大小写，但是如果你指的是数据类型，例如String（）必须大写，如果发现，我可以纠正所有情况，我使用Eclipse环境。听起来不错！我刚刚为
getMaxFrequency
添加了一个解决方案，如果遇到任何问题，请告诉我。谢谢，这是工作。