How to use

PriorityQueue

in

smile.sort

/**
 * fix up.
 */
private void swim(int k) {
  while (k > 1 && less(k, (k + d - 2) / d)) {
    swap(k, (k + d - 2) / d);
    k = (k + d - 2) / d;
  }
}

/**
 * Removes and returns the index of item with minimum value (highest priority).
 */
public int poll() {
  swap(1, n);
  sink(1, n - 1);
  return pq[n--];
}

  /**
   * The priority of item k has changed.
   */
  public void change(int k) {
    swim(qp[k]);
    sink(qp[k], n);
  }
}

@Override
public double[] dijkstra(int s) {
  double[] wt = new double[n];
  Arrays.fill(wt, Double.POSITIVE_INFINITY);
  PriorityQueue queue = new PriorityQueue(wt);
  for (int v = 0; v < n; v++) {
    queue.insert(v);
  }
  wt[s] = 0.0;
  queue.lower(s);
  while (!queue.empty()) {
    int v = queue.poll();
    if (!Double.isInfinite(wt[v])) {
      for (Edge edge : graph[v]) {
        int w = edge.v2;
        if (!digraph && w == v) {
          w = edge.v1;
        }
        
        double p = wt[v] + edge.weight;
        if (p < wt[w]) {
          wt[w] = p;
          queue.lower(w);
        }
      }
    }
  }
  
  return wt;
}

/**
 * Insert a new item into queue.
 * @param v the index of item.
 */
public void insert(int v) {
  pq[++n] = v;
  qp[v] = n;
  swim(n);
}

Arrays.fill(wt, Double.POSITIVE_INFINITY);
PriorityQueue queue = new PriorityQueue(wt);
for (int v = 0; v < n; v++) {
  queue.insert(v);
queue.lower(s);
while (!queue.empty()) {
  int v = queue.poll();
  if (!Double.isInfinite(wt[v])) {
    for (int w = 0; w < n; w++) {
        if (p < wt[w]) {
          wt[w] = p;
          queue.lower(w);

/**
 * The value of item k is lower (higher priority) now.
 */
public void lower(int k) {
  swim(qp[k]);
}

/**
 * fix down.
 */
private void sink(int k, int N) {
  int j;
  while ((j = d * (k - 1) + 2) <= N) {
    for (int i = j + 1; i < j + d && i <= N; i++) {
      if (less(i, j)) {
        j = i;
      }
    }
    if (!(less(j, k))) {
      break;
    }
    swap(k, j);
    k = j;
  }
}