索引优先队列

一、算法思想

　　优先队列的原理本质上就是利用完全二叉树的结构实现以log₂n的时间复杂度删除队列中的最小对象（这里以小堆顶为例）。完全二叉树又可以通过数组下标实现索引，当插入一个对象的时候，利用上浮操作更新最小对象。当删除堆顶最小对象时，将末尾的对象放置到堆顶上，然后执行下沉操作。

　　优先队列有一个缺点，就是不能直接访问已存在于优先队列中的对象，并更新它们。这个问题在Dijistra算法中就有明显的体现，有时候我们需要更新已在队列中的顶点的距离。为此就需要设计一种新型的数据结构来解决这个问题，这就是本文要介绍的索引优先队列。

　　索引优先队用一个整数和对象进行关联，当我们需要跟新该对象的值时，可以通这个整数进行快速索引，然后对对象的值进行更新。当然更新后的对象在优先队列中的位置可能发生变化，这样以保证整个队列还是一个优先队列。

二、算法流程

1，增加数组keys用来保存优先队列元素（item or key）

2，pq数组则改用于保存索引（pq[i] = k，k为索引），这里的pq数组仍然保持堆有序，即pq[1]所对应的元素（keys[pq[1]]）大于或等于pq[2]、pq[3]所对应的元素（keys[pq[2]]、keys[pq[3]]）。

3，增加数组qp，用于保存pq的逆序。如果pq[i] = k，则qp[k] = i，也就是pq[qp[k]] = k。如果k不在队列之中，则qp[k] = -1。

 

 

 

 

三、算法实现

package io.guangsoft;

import java.util.Arrays;

public class IndexMinPriorityQueue <T extends Comparable>{
    //用来存储元素的数组
    private T[] items;
    //保存每个元素在items数组中的索引，pq数组需要堆有序
    private int[] pq;
    //保存pq的逆序，pq值作为索引，pq的索引作为值
    private int[] qp;
    //记录堆中元素个数
    private int n;
    //创建容量为capacity的indexMinPriorityQueue
    IndexMinPriorityQueue(int capacity) {
        this.items = (T[])new Comparable[capacity + 1];
        this.pq = new int[capacity + 1];
        this.qp = new int[capacity + 1];
        this.n = 0;
        //默认情况下，队列中没有任何存储数据，让qp中的元素都为-1
        for(int i = 0; i < qp.length; i++) {
            qp[i] = -1;
        }
    }
    //获取队列中元素的个数
    public int size() {
        return n;
    }
    //判断队列是否为空
    public boolean isEmpty() {
        return n == 0;
    }
    //判断堆中索引i处的元素是否小于索引j处的元素
    private boolean less(int i, int j) {
        return items[pq[i]].compareTo(items[pq[j]]) < 0;
    }
    //交换堆中索引i处元素和索引j处元素
    private void swap(int i, int j) {
        //交换pq中的数据
        int tmp = pq[i];
        pq[i] = pq[j];
        pq[j] = tmp;
        //更新qp中的数据
        qp[pq[i]] = i;
        qp[pq[j]] = j;
    }
    //判断k对应的元素是否存在
    public boolean contains(int k) {
        return qp[k] != -1;
    }
    //最小元素关联索引
    public int minIndex() {
        return pq[1];
    }
    //删除队列中最小的元素，并返回该元素关联的索引
    public int delMin() {
        //获取最小元素的关联索引
        int minIndex = pq[1];
        //交换pq中索引1处和最大索引处的元素
        swap(1, n);
        //删除qp中对应的内容
        qp[pq[n]] = -1;
        //删除items中对应的内容
        items[minIndex] = null;
        //删除pq中最大索引处的内容
        pq[n] = -1;
        //元素个数-1
        n--;
        //下沉操作
        sink(1);
        return minIndex;
    }
    //删除索引i关联的元素
    public void delete(int i) {
        //找到i在pq中的索引
        int k = qp[i];
        //交换pq中索引k处的值和索引n处的值
        swap(k, n);
        //删除qp中的内容
        qp[pq[n]] = -1;
        //删除items中的内容
        items[k] = null;
        //删除pq中的内容
        pq[n] = -1;
        //元素的数量-1
        n--;
        //堆的调整
        sink(k);
        swim(k);
    }
    //往队列中插入一个元素，并关联索引
    public void insert(int i, T t) {
        //判断i是否已经被关联，如果已经被关联，则不允许插入
        if(contains(i)) {
            return;
        }
        //元素个数增加
        n++;
        //把数据存储到items对应的i位置
        items[i] = t;
        //把i存储到pq中
        pq[n] = i;
        //通过qp来记录pq中的i
        qp[i] = n;
        //通过堆上浮进行堆的调整
        swim(n);
    }
    //把与索引i关联的元素修改为t
    public void changeItem(int i, T t) {
        //修改items数组中i位置的元素为t
        items[i] = t;
        //找到i在pq中出现的位置
        int k = qp[i];
        //堆调整
        sink(k);
        swim(k);
    }
    //使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置
    private void swim(int k) {
        while(k > 1) {
            if(less(k, k / 2)) {
                swap(k, k / 2);
            }
            k /= 2;
        }
    }
    //使用下沉算法，使索引k处的元素能在堆中处于一个正确的位置
    private void sink(int k) {
        while(2 * k <= n) {
            //找到子节点中的较小值
            int min;
            if(2 * k + 1 <= n) {
                if(less(2 * k, 2 * k + 1)) {
                    min = 2 * k;
                } else {
                    min = 2 * k + 1;
                }
            } else {
                min = 2 * k;
            }
            //比较当前节点和较小值
            if(less(k, min)) {
                break;
            }
            swap(k, min);
            k = min;
        }
    }
    //主类
    public static void main(String args[]) {
        //创建索引最小优先队列和对象
        IndexMinPriorityQueue<Integer> queue = new IndexMinPriorityQueue<>(10);
        //往队列中添加元素
        queue.insert(0, 2);
        queue.insert(1, 1);
        queue.insert(2, 3);
        //测试修改
        queue.changeItem(2, 7);
        //测试删除
        System.out.print("队列的序列为：" + Arrays.toString(queue.items));
        System.out.println();
        System.out.print("最小值索引为：" );
        while(!queue.isEmpty()) {
            int index = queue.delMin();
            System.out.print(index + "\t");
        }
    }
 }

四、算法分析

　　索引优先队列，用一个索引数组保存了元素在数组中的位置。在插入队列中时，可看作将一个整数和一个对象相关联，使得我们可以引用队列中的元素。比如在Dijkstra算法中就用到了索引优先队列，他将顶点（整数表示）和源点到该顶点的最短路径长度关联起来，每次删除最小元素，都能得到与之关联的那个整数；如果该整数已经被关联了，还可以更新与该整数关联的对象。可以看出，索引优先队列和优先队列比起来，操作数组里面的元素更加方便了——这就是关联了索引带来的好处。时间复杂度为O(ElogV)。