Java数组模拟优先级队列数据结构的实例

优先级队列
如果我们给每个元素都分配一个数字来标记其优先级，不妨设较小的数字具有较高的优先级，这样我们就可以在一个集合中访问优先级最高的元素并对其进行查找和删除操作了。这样，我们就引入了优先级队列 这种数据结构。 优先级队列（priority queue） 是0个或多个元素的集合，每个元素都有一个优先权，对优先级队列执行的操作有（1）查找（2）插入一个新元素 （3）删除 一般情况下，查找操作用来搜索优先权最大的元素，删除操作用来删除该元素 。对于优先权相同的元素，可按先进先出次序处理或按任意优先权进行。

java数组模拟队列
队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。这也就是我们平常经常用说到的先进先出原则（fifo）。java 中的 list 就可以作为队列来使用，在队列尾部添加元素则使用 list.add 方法，从队列头部删除元素则使用 list.remove 方法。

java数组模拟优先级队列结构实例:

package datastruct; 
 
import java.util.arrays; 
import java.util.comparator; 
 
/** 
 * 用数组模拟 优先级队列 优先级高的排前、先出 线性表结构 
 * 类似使用了比较器的 treeset、treemap 
 */ 
public class simulatepriorityqueue { 
   
  public static void main(string[] args) { 
    simulatepriorityqueue queue = new simulatepriorityqueue(4); 
//   simulatequeue queue = new simulatequeue(); 
//   system.out.println("取出元素：" + queue.remove()); 
    queue.insert(1); 
    queue.insert(3); 
    queue.insert(2); 
    queue.insert(5); 
    queue.insert(4); 
    system.out.println("size:" + queue.size()); 
    system.out.println("peek:" + queue.peek()); 
    system.out.println("取出元素：" + queue.remove()); 
    system.out.println("取出元素：" + queue.remove()); 
    system.out.println("取出元素：" + queue.remove()); 
    system.out.println("取出元素：" + queue.remove()); 
//   system.out.println("取出元素：" + queue.remove()); 
    system.out.println("size:" + queue.size()); 
    system.out.println(); 
  } 
 
  private int msize = 3;     //大小 
  private int[] marray;    //数组 
  private int mnextitem;     //下一个位置，也可当作 当前的元素数 
   
  public simulatepriorityqueue() { 
    marray = new int[msize]; 
    mnextitem = 0; 
  } 
  public simulatepriorityqueue(int size) { 
    this.msize = size; 
    marray = new int[msize]; 
    mnextitem = 0; 
  } 
  /** 
   * 插入元素 
   * @param item 
   */ 
  public void insert(int item) { 
    if (!isfull()) { 
      marray[mnextitem++] = item; 
      for (int i = 0; i < mnextitem; i++) {//冒泡排序 
        for (int j = 0; j < mnextitem - 1; j++) { 
          if (marray[j] > marray[j + 1]) { 
            marray[j] = marray[j + 1] + 0 * (marray[j + 1] = marray[j]); 
            system.out.println(arrays.tostring(marray)); 
          } 
        } 
      } 
      system.out.println(arrays.tostring(marray)); 
    } else { 
      system.out.println("----不能插入元素了，队列已满----"); 
    } 
  } 
  /** 
   * 移出元素 先进先出 
   * @return 
   */ 
  public int remove() { 
    if (!isempty()) { 
      return marray[--mnextitem]; 
    } else { 
      throw new illegalargumentexception("没有元素可以取出了"); 
    } 
  } 
  /** 
   * 查看前面的元素 
   * @return 
   */ 
  public int peek() { 
    return marray[mnextitem - 1]; 
  } 
  /** 
   * 是否为空 
   * @return 
   */ 
  public boolean isempty() { 
    return mnextitem == 0; 
  } 
  /** 
   * 是否满 
   * @return 
   */ 
  public boolean isfull() { 
    return mnextitem == msize; 
  } 
  /** 
   * size 
   * @return 
   */ 
  public int size() { 
    return mnextitem; 
  } 
   
} 

输出结果：

[1, 0, 0, 0]
[1, 3, 0, 0]
[1, 2, 3, 0]
[1, 2, 3, 0]
[1, 2, 3, 5]
----不能插入元素了，队列已满----
size:4
peek:5
取出元素：5
取出元素：3
取出元素：2
取出元素：1
size:0