java - 分支和边界错误:无法将Node1强制转换为java.lang.Comparable

我试图在java中实现分支绑定搜索算法。我知道它的概念（它是如何工作的），但我不确定如何实现它。
我在google上找到了一些例子，但它们要复杂得多，我似乎无法理解它们我想用一种简单的方式来实现它。而且大多数都不在java中。
下面是我开始搜索的相关方法（这只是我代码的一部分）。
我认为需要对for循环进行适当的修改，以存储前沿节点和成本，然后以最小成本获取节点，然后再次执行搜索，直到找到目标节点并添加累计成本。
所以我想递归方法最适合这个。但我不知道如何实施。
下面没有给出任何编译错误，但给出的运行时错误是Node1 cannot be cast to java.lang.Comparable。有人愿意调查这个问题吗几个小时以来我一直在尝试，但似乎找不到任何解决办法。
而且，任何指引我走上正确道路的小代码都会非常有用。

 public void Search(Node1[] nodes, String startNode, int size){

  List<String> frontierNodes = new ArrayList<String>();
  Queue<Node1> frontierCosts = new PriorityQueue<Node1>();

    for(int i=0; i<size;i++) {

        if(startNode.equals(nodes[i].getStartNode())) { // user enters the startNode and goalNode

           frontierNodes.add(nodes[i].getEndNode());
           frontierCosts.add(new Node1(nodes[i].getCost()));
           frontierCosts.peek();
           System.out.println("Min cost" +frontierCosts.peek());
           int nodesLength = nodes.length - (frontierNodes.size());
           i--;
           System.out.println("remaining search nodes length" +nodesLength);

           //Search(nodes, frontierCosts.peek().getEndNode() ,nodesLength); // RECURSIVE CALL?
        }
    }

}

下面是存储文件信息的Node1类

class Node1 {
   String start, end;
   double cost;

   public Node1(String start, String end, double cost){
       this.start = start;
       this.end = end;
       this.cost = cost;
   }

   public Node1(double cost) { // alternate constructor to store cost in   priority queue
      this.cost = cost;
   }

   public String getStartNode(){
      return start;
   }

   public String getEndNode(){
      return end;
   }

   public double getCost(){
      return cost;
   }
}

以下是文件格式（startNode-endNode-cost）

A B 10
A C 12
B D 6
....

[编辑]：
我想实现分支和绑定搜索，程序要求用户输入startNode和goalNode，然后从Node1类（存储文件中的数据的类）访问数据，然后程序输入search方法（上面的方法），传递所有的nodes、startNode和length of nodes(size)。
如果startnode与node1[].getstartnode中的任何一个匹配，则它将相应的扩展节点存储在frontierNodes中，并将其相应的开销存储在优先级队列中的frontierCosts中（以选择最小的开销）。
然后程序查看优先队列并选择最小成本节点（队列前面），然后再次搜索（递归调用上面的搜索方法？）将该特定节点作为startnode并继续搜索。
当程序到达新的节点时，每一个新节点的代价应该是到目前为止访问路径的累计代价，程序应该输出路径和代价。

最佳答案

priorityqueue需要实现可比较接口的数据结构，除非您将比较器作为constructor传入。
改变应该很简单。

class Node1 implements Comparable<Node1> {
    String start, end;
    double cost;

    public Node1(String start, String end, double cost){
        this.start = start;
        this.end = end;
        this.cost = cost;
    }

    public Node1(double cost) { // alternate constructor to store cost in   priority queue
        this.cost = cost;
    }

    public String getStartNode(){
        return start;
    }

    public String getEndNode(){
        return end;
    }

    public double getCost(){
        return cost;
    }

    @Override
    public int compareTo(Node1 o) {
        return Double.compare(this.cost, o.cost);
    }
}

注意，如果您希望结果是确定性的，并且成本不是唯一的，那么您可能还需要使用start/end节点作为比较的一部分。
就你的主要逻辑而言，有几件事不太正确。
函数参数应该包括目标节点。
函数参数应该包括到目前为止使用的成本，以便在希望使用递归函数时跟踪该成本。
您的函数应该返回到达节点的最小成本。
如果图可以有循环，请考虑一种机制，以确保它不会重新访问以前访问过的节点。
一旦您有了一个成本可接受的可行解决方案，您需要使用该成本作为上限，以确保如果成本高于目前最好的解决方案，您将不会继续访问更多节点。