algorithm - branch & bound error : Node1 cannot be cast to java.lang.Comparable -

i trying implement branch & bound search algorithm in java. know concept (how works), not sure how implement it.

i found examples on google way more complex , can't seem understand them. want implement in simple way. of them not in java.

following relevant method search starts (this part of code). think loop needs modified appropriately store frontier nodes , costs , node least cost , perform search again until goal node found adding cumulative costs.
guess recursive method works best this. not sure how implement.

the following not giving me compiling error giving me run time error node1 cannot cast java.lang.comparable. kindly issue? have been trying since hours cant seem find solution.

also, small piece of code directs me in right path helpful.

 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 startnode , 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?         }      }  }  

following node1 class stores file information

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 store cost in   priority queue       this.cost = cost;    }     public string getstartnode(){       return start;    }     public string getendnode(){       return end;    }     public double getcost(){       return cost;    } } 

following file format(startnode endnode cost)

a b 10  c 12 b d 6 .... 

[edit]:

i want implement branch , bound search, program asks user enter startnode , goalnode , access data node1 class (where data file stored) , program enters search method (above method) passing nodes, startnode , length of nodes(size). if startnode matches of node1[].getstartnode, stores corresponding expanded nodes in frontiernodes , corresponding costs in frontiercosts in priority queue (to pick least cost). program peeks() priority queue & selects least cost node (front of queue) , searches again (recursive call above search method?) particular node startnode , search continues.
when program reaches new nodes, cost @ each new node should cumulative cost of path visited far , program should output path , cost.

priorityqueue needs data structure implements comparable interface unless pass in comparator constructor.

the change should pretty straightforward.

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 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);     } } 

note if want result deterministic , cost not unique, might need use start/end node part of comparison well.

for main logic, there couple things not quite right.

1. your function arguments should include goal node is.
2. your function arguments should include how cost have used far can keep track of if want use recursive function.
3. your function should return minimum cost reach node.
4. if graph can have loop, consider mechanism ensure not revisit nodes has visited previously.
5. once have possible solution acceptable cost, need use cost upper bound ensure not continue visit more nodes if cost has gone higher best solution far.