算法分析-优先队列

最大优先队列：使用堆来实现

代码：

package com.chenqing.test.linearList.queue;

public class MaxPriorityQueue<T extends Comparable<T>> {
    private T[] items;
    private int n;

    public MaxPriorityQueue(int capacity) {
        items = (T[]) new Comparable[capacity + 1];
        this.n = 0;
    }

    public int size() {
        return n;
    }

    private boolean compare(int i, int j) {
        return items[i].compareTo(items[j]) > 0;
    }

    private void exchange(int i, int j) {
        T temp = items[i];
        items[i] = items[j];
        items[j] = temp;
    }

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

    public void insert(T obj) {
        items[++n] = obj;
        swim(n);
    }


    public T delMax() {
        T maxVal = items[1];
        exchange(1, n);
        n--;
        sink(1);
        return maxVal;
    }

    private void swim(int k) {
        while (k > 1) {
            if (compare(k, k / 2)) {
                exchange(k, k / 2);
            }
            k = k / 2;
        }
    }

    private void sink(int k) {
        while (2 * k <= n) {
            int max;
            if (2 * k + 1 <= n) {
                if (compare(2 * k, 2 * k + 1)) {
                    max = 2 * k;
                } else {
                    max = 2 * k + 1;
                }
            } else {
                max = 2 * k;
            }
            if (compare(k, max)) {
                break;
            }
            exchange(k, max);
            k = max;
        }
    }
}

最小优先队列：

package com.chenqing.test.linearList.queue;

public class MinPriorityQueue <T extends Comparable<T>>{
    private T[] items;
    private int n;

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

    public int size(){
        return n;
    }

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

    private boolean compare(int i , int j){
        return items[i].compareTo(items[j]) < 0;
    }

    private void exchange(int i, int j){
        T temp = items[i];
        items[i] = items[j];
        items[j] = temp;
    }

    public void insert(T obj){
        items[++n] = obj;
        swim(n);
    }

    public T delMin(){
        T minObj = items[1];
        exchange(1, n);
        n--;
        sink(1);
        return minObj;
    }

    private void swim(int k){
        while (k > 1){
            if(compare(k, k/2)){
                exchange(k, k/2);
            }
            k = k/2;
        }
    }

    private void sink(int k){
        while (2*k <n ){
            int min;
            if(2*k+1 < n){
                if(compare(2*k, 2*k+1)){
                    min = 2*k;
                }else{
                    min = 2*k+1;
                }
            }else{
                min = 2*k;
            }
            if(compare(k, min)){
                break;
            }
            exchange(k, min);
            k = min;
        }
    }
}

索引最小优先队列：不同于以上两种优先队列，此队列可以访问队列中的任意元素，对元素进行操作

package com.chenqing.test.linearList.queue;

public class IndexMinPriorityxQueue <T extends Comparable<T>>{
    private T[] items;
    private int[] pq;
    private int[] qp;
    private int n;

    public IndexMinPriorityxQueue(int capacity) {
        this.items = (T[]) new Comparable[capacity+1];
        pq = new int[capacity+1];
        qp = new int[capacity+1];
        n = 0;
        for (int i = 0; i < qp.length; i++) {
            qp[i] = -1;
        }
    }

    private boolean compare(int i, int j){
        return items[pq[i]].compareTo(items[pq[j]]) < 0;
    }

    private void exchange(int i, int j){
        int k = pq[i];
        pq[i] = pq[j];
        pq[j] = k;

        qp[pq[i]] = i;
        qp[pq[j]] = j;
    }

    public int delMin(){
        int minIndex = pq[1];
        exchange(1, n);
        qp[pq[n]]=-1;
        pq[n] = -1;
        items[minIndex] = null;
        n--;
        sink(1);
        return minIndex;
    }

    public void insert(T obj){
       insert(n, obj);
    }

    public void insert(int i, T obj){
       if(contains(i)){
           return;
       }
       n = n+1;
       items[i] = obj;
       pq[n] = i;
       qp[i] = n;
       swim(n);
    }

    private void swim(int k){
        while (k > 1){
            if(compare(k, k/2)){
                exchange(k, k/2);
            }
            k = k/2;
        }
    }

    private void sink(int k){
        while (2*k < n){
            int min;
            if(2*k+1 < n){
                if(compare(2*k, 2*k+1)){
                    min = 2*k;
                }else{
                    min = 2*k+1;
                }
            }else{
                min = 2*k;
            }
            if(compare(k, min)){
                break;
            }
            exchange(k, min);
            k = min;
        }
    }

    public int size(){
        return n;
    }

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

    public boolean contains(int k){
        return qp[k] != -1;
    }

    public void changeItem(int i, T t){
        items[i] = t;
        int k = qp[i];
        swim(k);
        sink(k);
    }

    public int minIndex(){
        return pq[1];
    }

    public void delete(int i){
        int k = qp[i];
        exchange(k, n);
        pq[n] = -1;
        qp[k] = -1;
        items[i] = null;
        n--;
        swim(k);
        sink(k);
    }
}