Java 最小优先队列API设计与实现

Java 学习+面试指南：https://javaxiaobear.cn

• 最小的元素放在数组的索引1处。
• 每个结点的数据总是小于等于它的两个子结点的数据。

1、API设计

类名	MinPriorityQueue
构造方法	MinPriorityQueue(int capacity)：创建容量为capacity的MinPriorityQueue对象
成员方法	private boolean less(int i,int j)：判断堆中索引i处的元素是否小于索引j处的元素 private void exch(int i,int j):交换堆中i索引和j索引处的值 public T delMin():删除队列中最小的元素,并返回这个最小元素 public void insert(T t)：往队列中插入一个元素 private void swim(int k):使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置 private void sink(int k):使用下沉算法，使索引k处的元素能在堆中处于一个正确的位置 public int size():获取队列中元素的个数 public boolean isEmpty():判断队列是否为空
成员变量	private T[] imtes : 用来存储元素的数组 private int N：记录堆中元素的个数

2、代码实现

public class MinPriorityQueue<T extends Comparable<T>> {

    private T[] items;

    private int size;

    public MinPriorityQueue(int capacity){
        items = (T[]) new Comparable[capacity+1];
        size = 0;
    }

    /**
     * 判断堆中索引i处的元素是否小于索引j处的元素
     * @param i
     * @param j
     * @return
     */
    private boolean less(int i,int j){
        return items[i].compareTo(items[j]) < 0;
    }

    /**
     * 交换堆中i索引和j索引处的值
     * @param i
     * @param j
     */
    private void each(int i,int j){
        T temp = items[i];
        items[i] = items[j];
        items[j] = temp;
    }

    /**
     * 删除队列中最小的元素,并返回这个最小元素
     * @return
     */
    public T delMin(){
        T min = items[1];
        each(1,size);
        items[size] = null;
        size--;
        sink(1);
        return min;
    }

    /**
     * 往队列中插入一个元素<br/>
     * @param t
     */
    public void insert(T t){
        items[++size] = t;
        swim(size);
    }

    /**
     * :使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置<br/>
     * @param k
     */
    private void swim(int k){
        while (1 < k){
            if(less(k,k/2)){
                each(k,k/2);
            }
            k = k/2;
        }
    }

    /**
     * 使用下沉算法，使索引k处的元素能在堆中处于一个正确的位置
     * @param k
     */
    private void sink(int k){
        while (2*k <= size){
            int min = 2*k;
            //如果存在右子结点
            if(2*k + 1 <= size){
                if(less(2*k + 1,2*k)){
                    min = 2*k + 1;
                }
            }
            if(less(k,min)){
                break;
            }
            each(min,k);
            k = min;
        }
    }

    /**
     * 获取队列中元素的个数
     * @return
     */
    public int size(){
        return size;
    }

    /**
     * 判断队列是否为空
     * @return
     */
    public boolean isEmpty(){
        return size == 0;
    }
}

• 测试类

  public class MinPriorityQueueTest {
      public static void main(String[] args) {
          String[] arr = {"G", "F", "E", "D", "C", "B", "A"};
          MinPriorityQueue<String> queue = new MinPriorityQueue(10);
          for (String s : arr) {
              queue.insert(s);
          }
          System.out.println(queue.size());
          String del;
          while (!queue.isEmpty()){
              del = queue.delMin();
              System.out.print(del+" ");
          }
      }
  }
  

  输出结果

  7
  A B C D E F G