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

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