Priority queue : Queue « Collections Data Structure « Java

1. Java
2. Collections Data Structure
3. Queue

Priority queue

     

public class PriorityQ {
  // array in sorted order, from max at 0 to min at size-1
  private int maxSize;

  private long[] queArray;

  private int nItems;

  public PriorityQ(int s) {
    maxSize = s;
    queArray = new long[maxSize];
    nItems = 0;
  }

  public void insert(long item) {
    int i;

    if (nItems == 0)
      queArray[nItems++] = item; // insert at 0
    else 
    {
      for (i = nItems - 1; i >= 0; i--) // start at end,
      {
        if (item > queArray[i]) // if new item larger,
          queArray[i + 1] = queArray[i]; // shift upward
        else
          // if smaller,
          break; // done shifting
      }
      queArray[i + 1] = item; // insert it
      nItems++;
    } // end else (nItems > 0)
  }

  public long remove(){
    return queArray[--nItems];
  }

  public long peekMin(){
    return queArray[nItems - 1];
  }

  public boolean isEmpty(){
    return (nItems == 0);
  }

  public boolean isFull(){
    return (nItems == maxSize);
  }
  public static void main(String[] args) {
    PriorityQ thePQ = new PriorityQ(5);
    thePQ.insert(30);
    thePQ.insert(50);
    thePQ.insert(10);
    thePQ.insert(40);
    thePQ.insert(20);

    while (!thePQ.isEmpty()) {
      long item = thePQ.remove();
      System.out.print(item + " "); // 10, 20, 30, 40, 50
    }
    System.out.println("");
  }
}
           
         
    
    
    
    
  

Related examples in the same category

1.	Queue data structure
2.	Convert a Queue to a List
3.	Create a queue using LinkedList class
4.	Simple Queue (FIFO) based on LinkedList
5.	The Generic Queue Class
6.	Blocking Queue
7.	Circular Queue
8.	Circular Queue extends AbstractList
9.	How to extend the collections framework
10.	An unbounded {@link TransferQueue} based on linked nodes.
11.	This class implements the data structures necessary for an ArrayQueue
12.	A circular queue from mina
13.	An unbounded TransferQueue based on linked nodes.
14.	Rotating queue of fixed size.
15.	Allows threads to communicate asynchronously by putting messages into and reading messages out of a synchronized queue.