Java 如何计算数据结构中的相同名称？

我需要在二叉搜索树和单链表中计算相同学生的名字。但我找不到该怎么做。有人对此有答案吗

public class Student  {

   private int ID;
   private String name;
   private String surname;

   public Student(int id, String n, String s)
   {
      ID = id;
      name = n;
      surname = s;
   }

   public int getID() 
   {
      return ID;
   }

   public String getName() 
   {
      return name;
   }

   public String getSurname()
   {
      return surname;      
   }

   public void setID(int newID) 
   { 
      ID = newID; 
   }

   public void setName(String newName) 
   { 
      name = newName; 
   }

   public void setSurname(String newSurname)
   {
      surname = newSurname;
   }

   public String ToString()
   {
      return "\nname : "+name+"\nsurname : "+surname+"\nid : "+ID+"\n"; 
   }
}

学生班以上

public class NodeBST 
{
   private Student s;
   private NodeBST left;
   private NodeBST right;
   private int index ;

   public NodeBST(Student newS) 
   {
      s = newS;
      left = null;
      right = null;
      index = 0 ;
   }

   public int getIndex(){
      return index ;
   }

   public Student getStudent() 
   { 
      return s;
   }

   public NodeBST getLeft() 
   {
      return left; 
   }

   public NodeBST getRight() 
   {
      return right; 
   }

   public void setIndex(int idx){
      index = idx ;
   }

   public void setStudent(Student newS) 
   { 
      s = newS; 
   }

   public void setLeft(NodeBST newLeft) 
   {
      left = newLeft; 
   }

   public void setRight(NodeBST newRight) 
   {
      right = newRight; 
   }

   public boolean hasLeft() 
   {
       return (left != null);
   }

   public boolean hasRight() 
   {
       return (right != null);
   }
}

上面的二叉搜索树的节点类

import java.util.*;
public class BST 
{
   private NodeBST root;   
   int size ;
   String[] names ;

   public BST() 
   {
      names = new String[50];
      root = null;
      size = 0 ;
   }

   public BST(NodeBST newNodeBST) 
   {
      root = newNodeBST;
   }

   public boolean isEmpty() 
   {
      return (root == null);
   }

   public void insert(NodeBST newNodeBST) 
   {
      if(isEmpty())
      { // root is null
         root = newNodeBST;
         root.setIndex(size);
         names[size] = root.getStudent().getName() ;
         size++;
      }
      else
      {
         NodeBST tempNodeBST = root;
         while(true)
         {
            if(newNodeBST.getStudent().getID() < tempNodeBST.getStudent().getID())
            {
               if(tempNodeBST.getLeft() == null)
               {
                  tempNodeBST.setLeft(newNodeBST);
                  tempNodeBST.getLeft().setIndex(size);
                  size++;
                  break;
               }   
               else
                  tempNodeBST = tempNodeBST.getLeft();
            }
            else
            {
               if(tempNodeBST.getRight() == null)
               {
                  tempNodeBST.setRight(newNodeBST);
                  tempNodeBST.getRight().setIndex(size);
                  size++;
                  break;
               }   
               else
                  tempNodeBST = tempNodeBST.getRight();
            }
        }   
    }

import java.util.*；
公共类BST
{
私有NodeBST根；
整数大小；
字符串[]名称；
公共BST（）
{
名称=新字符串[50]；
root=null；
尺寸=0；
}
公共BST（NodeBST newNodeBST）
{
root=newNodeBST；
}
公共布尔值为空（）
{
返回（root==null）；
}
公共无效插入（NodeBST newNodeBST）
{
if（isEmpty（））
{//root为空
root=newNodeBST；
root.setIndex（大小）；
名称[大小]=root.getStudent（）.getName（）；
大小++；
}
其他的
{
NodeBST tempNodeBST=根；
while（true）
{
if（newNodeBST.getStudent（）.getID（）

有一种方法可以在二元搜索三中插入student。因此，我如何在这个二元搜索树中计算相同的名称。下面是我如何尝试这样做的，但没有成功

    public void nameCounter(){
    String [] tempNames = names ;
    for(int element = 0 ; element < size ; element++){
        int contains = 1 ;
        for(int counter = element ; counter < size ; counter++){
            if(tempNames[element].equals(tempNames[counter]) && element != counter)        { 
               contains++;
            }
        }
        System.out.println(tempNames[element] +" : "+contains);
    }
}

public void nameconter（）{
字符串[]tempNames=名称；
对于（int元素=0；元素<大小；元素++）{
int=1；
用于（int计数器=元素；计数器<大小；计数器++）{
if（tempNames[element].equals（tempNames[counter]）&&element！=counter）{
包含++；
}
}
System.out.println（tempNames[element]+“：”+contains）；
}
}

---

如何解决这个问题？

最简单的例子是什么，当您尝试调试程序时，在调试器中单步执行代码时，您会看到什么？当我在二进制搜索树中添加4个相同的名称时，它看起来是这样的：asil:4 asil:3 asil:3@peterlawrey您可以包含一个您编写的测试来重现这个问题吗？什么数组在树中的用途是什么？是否仅用于调试？如果忽略数组而只查看树中的节点，您会看到什么？