title: Dijkstra's algorithm java implementation bug
body: <p>So first of all this is HW, so try not to just give me the answer right away, but I'm having trouble programming Dijstra's Algorithm. The lab has us build a priority Queue, which I have made and passes the given JUnit tests so I think it's correct. The second part of the lab had us use the queue in an implementation of dijstra's algorithm. Here is my code for Dijkstra's</p>
  
  <pre><code>/**
   * Compute shortest paths in a graph.
   *
   * Your constructor should compute the actual shortest paths and
   * maintain all the information needed to reconstruct them.  The
   * returnPath() function should use this information to return the
   * appropriate path of edge ID's from the start to the given end.
   *
   * Note that the start and end ID's should be mapped to vertices using
   * the graph's get() function.
   */
  
  class ShortestPaths {
  
      Multigraph graph;
      final int INF = Integer.MAX_VALUE;
      PriorityQueue&lt;Integer&gt; Q;
      int n;
      int dist[];
      Handle handles[];
      Edge edge[];
  
      /**
       * Constructor
       */
      public ShortestPaths(Multigraph G, int startId) {
          Q = new PriorityQueue&lt;Integer&gt;();
          graph = G;
          n = graph.nVertices();
          dist = new int [n];
          edge = new Edge [n];
          handles = new Handle[n];
  
          for (int i = 0; i&lt;n; i++){
              dist[i] = INF;
          }
          dist[startId] = 0;
  
          Handle h = Q.insert(startId, dist[startId]);
          handles[startId] = h;   
          Q = new PriorityQueue&lt;Integer&gt;();
          while (!Q.isEmpty()){
              Vertex v = graph.get(Q.min());
              Q.extractMin();
              while (v.adj().hasNext()){
                  relax(v.adj().next());  
              }       
          }   
      }
  
      private void relax(Edge e) {
          Handle h;
          int v = e.from().id();
          int w = e.to().id();
          if (dist[w] &gt; dist[v] + e.weight()) {
              dist[w] = dist[v] + e.weight();
              edge[w] = e;
              if (handles[w].getIndex() != -1){
                  Q.decreaseKey(handles[w], dist[w]);
              }
              else{
                  h = Q.insert(w, dist[w]);
                  handles[w] = h;
              }
          }
      }
  
      /**
       * Calculates the list of edge ID's forming a shortest path from the start
       * vertex to the specified end vertex.
       *
       * @return the array
       */
      public int[] returnPath(int endId) {
          int c = 0;
          int[] path = new int[edge.length];
          for (Edge e = edge[endId]; e != null; e = edge[e.from().id()]) {
              path[c] = e.id();
              c++;
          }
          return path;
      }
  
  
  }
  </code></pre>
  
  <p>Just so you know, a handle is simply an object which stores the index of the associated key-value pair, that way we can find it later. The handles update automatically, you can see this in the swap procedure in my priority queue. Anyway, The issue is that my edge[] array is populated with null for some reason, so I can't return any paths. How do I fix my algorithm to update edge[] correctly? Any help would be appreciated. Just tell me if you would like more information. Also I will post the Vertex and Edge classes in case you want to look at those.</p>