Java:在二叉搜索树中查找学生GPA的排名

这让我很头疼。我已经阅读了所有与这个问题相关的帖子，但是我仍然很难理解如何实现这个算法。我花了几个小时试着学习

我有一个完整编写的BST，其中包含递归添加、删除ect

Student

对象的方法（尽管BST类是为泛型编写的）。我需要编写一个方法，根据学生的GPA返回学生在二叉搜索树中的排名，但我不知道该如何实现。

Student

类有一个getGPA（）方法，所以我知道我需要以某种方式使用它

我应该将元素存储到数组中，然后搜索索引吗？如果是这样的话，实现这一点的最佳算法是什么？有更好的方法吗？如果有人能帮我解决这个问题，我将非常感激

以下是我的BST课程的重要部分：

public int size()
    // Returns the number of elements in this BST.
    {
      return recSize(root);
    }
private int recSize(BSTNode<T> tree)
  // Returns the number of elements in tree.
  {
    if (tree == null)    
      return 0;
    else
      return recSize(tree.getLeft()) + recSize(tree.getRight()) + 1;
  }
private boolean recContains(T element, BSTNode<T> tree)
  // Returns true if tree contains an element e such that 
  // e.compareTo(element) == 0; otherwise, returns false.
  {
    if (tree == null)
      return false;       // element is not found
    else if (element.compareTo(tree.getInfo()) < 0)
      return recContains(element, tree.getLeft());   // Search left subtree
    else if (element.compareTo(tree.getInfo()) > 0)
      return recContains(element, tree.getRight());  // Search right subtree
    else
      return true;        // element is found
  }

  public boolean contains (T element)
  // Returns true if this BST contains an element e such that 
  // e.compareTo(element) == 0; otherwise, returns false.
  {
    return recContains(element, root);
  }
private T recGet(T element, BSTNode<T> tree)
  // Returns an element e from tree such that e.compareTo(element) == 0;
  // if no such element exists, returns null.
  {
    if (tree == null)
      return null;             // element is not found
    else if (element.compareTo(tree.getInfo()) < 0)
      return recGet(element, tree.getLeft());          // get from left subtree
    else
    if (element.compareTo(tree.getInfo()) > 0)
      return recGet(element, tree.getRight());         // get from right subtree
    else
      return tree.getInfo();  // element is found
  }

  public T get(T element)
  // Returns an element e from this BST such that e.compareTo(element) == 0;
  // if no such element exists, returns null.
  {
    return recGet(element, root);
  }

  private BSTNode<T> recAdd(T element, BSTNode<T> tree)
  // Adds element to tree; tree retains its BST property.
  {
    if (tree == null)
      // Addition place found
      tree = new BSTNode<T>(element);
    else if (element.compareTo(tree.getInfo()) <= 0)
      tree.setLeft(recAdd(element, tree.getLeft()));    // Add in left subtree
    else
      tree.setRight(recAdd(element, tree.getRight()));   // Add in right subtree
    return tree;
  }

  public void add (T element)
  // Adds element to this BST. The tree retains its BST property.
  {
    root = recAdd(element, root);
  }
private void inOrder(BSTNode<T> tree)
  // Initializes inOrderQueue with tree elements in inOrder order.
  {
    if (tree != null)
    {
      inOrder(tree.getLeft());
      inOrderQueue.enqueue(tree.getInfo());
      inOrder(tree.getRight());
    }
  }
private void preOrder(BSTNode<T> tree)
  // Initializes preOrderQueue with tree elements in preOrder order.
  {
    if (tree != null)
    {
      preOrderQueue.enqueue(tree.getInfo());
      preOrder(tree.getLeft());
      preOrder(tree.getRight());
    }
  }

  private void postOrder(BSTNode<T> tree)
  // Initializes postOrderQueue with tree elements in postOrder order.
  {
    if (tree != null)
    {
      postOrder(tree.getLeft());
      postOrder(tree.getRight());
      postOrderQueue.enqueue(tree.getInfo());
    }
  }

  public int reset(int orderType)
  // Initializes current position for an iteration through this BST
  // in orderType order. Returns current number of nodes in the BST.
  {
    int numNodes = size();

    if (orderType == INORDER)
    {
      inOrderQueue = new LinkedUnbndQueue<T>();
      inOrder(root);
    }
    else
    if (orderType == PREORDER)
    {
      preOrderQueue = new LinkedUnbndQueue<T>();
      preOrder(root);
    }
    if (orderType == POSTORDER)
    {
      postOrderQueue = new LinkedUnbndQueue<T>();
      postOrder(root);
    }
    return numNodes;
  }

public int size（）
//返回此BST中的元素数。
{
返回大小（根）；
}
私有int recSize（BSTNode树）
//返回树中的元素数。
{
if（tree==null）
返回0；
其他的
返回recSize（tree.getLeft（））+recSize（tree.getRight（））+1；
}
私有布尔recContains（T元素，BSTNode树）
//如果树中包含元素e，则返回true
//e.比较（元素）==0；否则，返回false。
{
if（tree==null）
返回false；//未找到元素
else if（element.compareTo（tree.getInfo（））<0）
return recContains（元素，tree.getLeft（））；//搜索左子树
else if（element.compareTo（tree.getInfo（））>0）
return recContains（元素，tree.getRight（））；//搜索右子树
其他的
返回true；//找到元素
}
公共布尔包含（T元素）
//如果此BST包含元素e，则返回true
//e.比较（元素）==0；否则，返回false。
{
返回recContains（元素，根）；
}
私有T recGet（T元素，BSTNode树）
//从树中返回元素e，使e.compareTo（元素）==0；
//如果不存在这样的元素，则返回null。
{
if（tree==null）
返回null；//未找到元素
else if（element.compareTo（tree.getInfo（））<0）
返回recGet（元素，tree.getLeft（））；//从左子树获取
其他的
if（element.compareTo（tree.getInfo（））>0）
返回recGet（元素，tree.getRight（））；//从右子树获取
其他的
返回树。getInfo（）；//找到元素
}
公共T获取（T元素）
//从该BST返回元素e，使得e.compareTo（元素）==0；
//如果不存在这样的元素，则返回null。
{
返回recGet（元素，根）；
}
私有BSTNode recAdd（T元素，BSTNode树）
//将元素添加到树中；树保留其BST属性。
{
if（tree==null）
//找到添加位置
树=新节点（元素）；
else if（element.compareTo（tree.getInfo（））在几次失败后，我似乎找到了一个可行的解决方案。我决定不使用固定大小的通用数组存储，而是尝试使用ArrayList。我使用递归方法将每个节点按顺序添加到数组列表中：

//recursive method used to copy BST to array list
    public void recArrayList(BSTNode<T> tree, ArrayList<T> list)
    {
        if (tree == null)
        {
            return;
        }
        recArrayList(tree.getLeft(), list);
        list.add(tree.getInfo());
        recArrayList(tree.getRight(), list);
    }

    //converts BST to arraylist used for finding GPA rank
    public ArrayList<T> toArrayList()
    {
        stuList = new ArrayList<T>();
        recArrayList(root, stuList);
        return stuList;
    }

//用于将BST复制到数组列表的递归方法
public void recArrayList（节点树，ArrayList列表）
{
if（tree==null）
{
返回；
}
recArrayList（tree.getLeft（），list）；
添加（tree.getInfo（））；
recArrayList（tree.getRight（），list）；
}
//将BST转换为用于查找GPA列组的arraylist
公共ArrayList到ArrayList（）
{
stuList=newarraylist（）；
recArrayList（根，stuList）；
返回列表；
}

最后，在使用BST的类中：

//returns the rank of student in BST based off GPA
    public int rank(Student stu)
    {
        ArrayList<Student> stuList = stuGPA.toArrayList();
        for (i = 0; i < stuList.size(); i++)
        {
            if (stuList.get(i) == stu)
            {
                return i + 1;
            }
        }
        return 0;
    }

//返回基于GPA的学生在BST中的排名
公共int等级（学生stu）
{
ArrayList stuList=stuGPA.toArrayList（）；
对于（i=0；i

我不喜欢使用
==
来比较引用，所以我正在努力改变它，但现在它似乎运行正常。对于这些评论，它启发了我走另一条路。
你只是想通过在树中找到一个学生并获得is GPA值来找到GPA吗？如果是这样，有很多树遍历m在尝试递归遍历树以查找特定节点或节点上的特定对象时，这种方法非常有帮助。下面是一个url：您似乎有一个方法，
inorder
，它将对象添加到有序队列中。只需这样做，然后在队列中查找对象的索引。@Raheel138 OP不想这样做d GPA.OP试图根据某人的GPA查找其班级排名。请看以下内容：