zoukankan      html  css  js  c++  java
  • 优先队列

    数据结构与算法(五),优先队列

     

    这节总结一下优先队列的常用实现方法。

    1、基本概念

    普通的队列是一种先进先出的数据结构,元素在队列尾追加,而从队列头删除。在优先队列中,元素被赋予优先级。当访问元素时,具有最高优先级的元素最先删除。优先队列具有最高级先出 (largest-in,first-out)的行为特征。(百度百科)

    抽象数据类型:

    优先队列的接口同前面讲到的队列的接口一样,是其基于泛型的API接口代码如下:

    public interface Queue<E> {
    
        //队列是否为空
        boolean isEmpty();
    
        //队列的大小
        int size();
    
        //入队
        void enQueue(E element);
    
        //出队
        E deQueue();
    }

    2、基于数组实现的优先队列

    实现优先队列最简的方法就是基于前面讲到的基于数组的栈的代码,只需对插入或删除操作作相应的更改即可。

    2.1、基于有序数组的实现

    在栈的代码的插入方法中添加代码,将所有较大的元素向右移动一格,以保证数组有序(和插入排序相同),这里我们可以使用二分查找的方法来找出元素应插入的位置,然后再移动元素。这样最大元素,总是在数组的最右边,其删除操作和栈的实现中一样。

    代码:

    /**
     * 基于有序数组的实现的优先队列
     * @author Alent
     * @param <E>
     */
    public class PriorityQueue<E extends Comparable<E>> implements Queue<E>{
        private E[] elements;
        private int size=0;
        
        @SuppressWarnings("unchecked")
        public PriorityQueue() {
            elements = (E[])new Comparable[1]; 
        }
        
        @Override public int size() {return size;}
    
        @Override public boolean isEmpty() {return size == 0;}
    
        @Override
        public void enQueue(E element) {
            if(size == elements.length) {
                resizingArray(2*size);//若数组已满将长度加倍
            }
            elements[size++] = element;
            insertSort(elements);
        }
    
        @Override
        public E deQueue() {
            E element = elements[--size];
            elements[size] = null;     //注意:避免对象游离
            if(size > 0 && size == elements.length/4) {
                resizingArray(elements.length/2);//小于数组1/4,将数组减半
            }
            return element;
        }
        
        //插入排序,由于前面n-1个元素是有序的,这里只插入最后一个元素
        public void insertSort(E[] a) {
            int N = size -1; //最后一个元素是size-1,不是a.length-1
            if(N == 0) return;
            int num = binaryFind(a, a[N], 0, N-1);
            E temp = a[N];
            //num后的元素向后移动
            for (int j = N; j > num; j--) {
               a[j] = a[j-1];
            }
            a[num] = temp;
        }
    
        //找出元素应在数组中插入的位置
        public int binaryFind(E[] a, E temp, int down, int up) {
            if(up<down || up>a.length || down<0) {
                System.out.println("下标错误");
            }
            if(temp.compareTo(a[down]) < 0) return down;
            if(temp.compareTo(a[up]) > 0) return up+1;
            int mid = (up-down)/2 + down;
            if(temp.compareTo(a[mid]) == 0) {
                return mid + 1;
            }else if(temp.compareTo(a[mid])<0) {
                up = mid-1;
            }else if(temp.compareTo(a[mid])>0) {
                down = mid+1;
            }
            return binaryFind(a,temp,down,up);
        }
    
        //交换两个元素
        public void swap(E[] a,int i,int j) {
            E temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }
        
        //调整数组大小
        public void resizingArray(int num) {
            @SuppressWarnings("unchecked")
            E[] temp = (E[])new Comparable[num];
            for(int i=0;i<size;i++) {
                temp[i] = elements[i];
            }
            elements = temp;
        }
        
        public static void main(String[] args) {
            int[] a = {4,2,1,3,8,new Integer(5),7,6};//测试数组
            PriorityQueue<Integer> pq = new PriorityQueue<Integer>();
            System.out.print("入栈顺序:");
            for(int i=0;i<a.length;i++) {
                System.out.print(a[i]+" ");
                pq.enQueue(a[i]);
            }
            System.out.println();
            System.out.print("出栈顺序数组实现:");
            while(!pq.isEmpty()) {
                System.out.println(pq.deQueue());
            }
        }
    }

    2.2、基于无序数组的实现

    同样,我们一个可以在删除方法中修改,在删除方法中添加一段类似于选择排序内循环的代码,每次删除时先找出数组中的最大元素,然后与最右边元素进行交换,然后在删除元素。

    代码:

    @Override
    public void enQueue(E element) {
        if(size == elements.length) {
            resizingArray(2*size);//若数组已满将长度加倍
        }
        elements[size++] = element;
    }
    
    @Override
    public E deQueue() {
        swapMax(elements);
        E element = elements[--size];
        elements[size] = null;     //注意:避免对象游离
        if(size > 0 && size == elements.length/4) {
            resizingArray(elements.length/2);//小于数组1/4,将数组减半
        }
        return element;
    }
    
    public void swapMax(E[] a) {
        int max = size -1;
        for(int i=0;i<size-1; i++) {
            if(larger(a[i],a[max])) 
                max = i;
        }
        swap(a, size-1, max);
    }
    
    //比较两个元素大小
    public boolean larger(E a1, E a2) {
        return a1.compareTo(a2)>0;
    }

    3、基于堆实现的优先队列

    基本概念:

    当一个二叉树的每个结点都大于等于它的两个子结点时,我们称它是堆有序的。根结点是堆有序的二叉树的最大结点。

    二叉堆是一组能够用堆有序的完全二叉树排序的元素,并在数组中按照层级存储。

    一棵堆有序的完全二叉树

    堆有序的完全二叉树

    为了操作方便,这是我们使用一个数组,来表示一个堆。我们不使用数组的第一个元素,具体实现在《数据结构与算法(四),树》中有提及,这里就不说了。

    3.1、堆的有序化

    当我们将元素插入到堆(数组的末尾)中时,插入的元素可能比它的父结点要大,堆的有序状态被打破。我们需要交换它和它的父节点来修堆,直到堆重新变为有序状态。其操作如下图:

    堆的插入操作

    代码如下:

    //上浮操作
    private void swim(int k) {
            while(k > 1 && less(k/2, k)) {
                swap(k/2, k);
                k = k/2;
            }
        }
    
    private boolean less(int i, int j) {
        return elements[i].compareTo(elements[j]) < 0;
    }
    
    //交换两个元素
    public void swap(int i,int j) {
        E temp = elements[i];
        elements[i] = elements[j];
        elements[j] = temp;
    }

    同样的,当我们从堆中删除根结点并将它的最后一个元素放到顶端时,堆的有序性被打破,我们需要将它与它的两个子结点种的较大者进行交换,以恢复堆的有序性,其操作流程如下图:

    其代码如下:

    //下沉操作
    private void sink(int k) {
        while(2*k <= size) {
            int j = 2*k;
            if(j < size && less(j, j+1))
                j++;
            if(!less(k,j))
                break;
            swap(k,j);
            k = j;
        }
    }

    3.2、基于堆实现的优先队列

    基于堆的优先队列的实现代码如下:

    /**
     * 基于堆的优先队列
     * @author Alent
     */
    public class MaxPQ<E extends Comparable<E>> implements Queue<E>{
        private E[] elements;
        private int size=0;
        
        @SuppressWarnings("unchecked")
        public MaxPQ(int capacity) {
            elements = (E[])new Comparable[capacity + 1]; 
        }
        
        @Override public int size() {return size;}
    
        @Override public boolean isEmpty() {return size == 0;}
    
        @Override
        public void enQueue(E element) {
            elements[++size] = element;
            swim(size);
        }
        
        //上浮
        private void swim(int k) {
            while(k > 1 && less(k/2, k)) {
                swap(k/2, k);
                k = k/2;
            }
        }
        
        private boolean less(int i, int j) {
            return elements[i].compareTo(elements[j]) < 0;
        }
    
        @Override
        public E deQueue() {
            E result = elements[1];
            swap(1, size--);
            elements[size + 1] = null;
            sink(1);
            return result;
        }
        
        //下沉
        private void sink(int k) {
            while(2*k <= size) {
                int j = 2*k;
                if(j < size && less(j, j+1))
                    j++;
                if(!less(k,j))
                    break;
                swap(k,j);
                k = j;
            }
        }
    
        //交换两个元素
        public void swap(int i,int j) {
            E temp = elements[i];
            elements[i] = elements[j];
            elements[j] = temp;
        }
    }

    三种实现方法的时间复杂度比较:

    时间复杂度

    4、索引优先队列

    索引优先队列,它用一个索引数组保存了某个元素在优先队列中的位置,使得我们能够引用已经进入优先队列中的元素。最在些应用中,通常是很有必要的,如:有向图的Dijkstra算法中就使用了索引优先队列,来返回最小边的索引。

    其实现方法为:

    使用elements[]数组来保存队列中的元素,pq[]数组用来保存elements中元素的索引,在添加一个数组qp[]来保存pq[]的逆序——qp[i]的值是i在pq[]中的位置(即 pq[qp[i]] = i)。若i不在队列中,则令qp[i] = -1。辅助函数less()、swap()、sink()、swim()和前面优先队列中的一样。

    索引优先队列的代码实现:

    /**
     * 基于堆实现的索引优先队列
     */
    public class IndexMinPQ<E extends Comparable<E>>{
    
        private int[] pq; //索引二叉堆
        private int[] qp; // 保存逆序:pq[qp[i]] = i;
        private E[] elements; //元素
        private int size = 0;
    
        @SuppressWarnings("unchecked")
        public IndexMinPQ(int capacity) {
            elements = (E[]) new Comparable[capacity + 1];
            pq = new int[capacity + 1];
            qp = new int[capacity + 1];
            for (int i = 0; i <= capacity; i++) {
                qp[i] = -1;
            }
        }
    
        public boolean isEmpty() {
            return size == 0;
        }
        //删除最小元素,并返回索引
        public int delMin() {
            int index = pq[1];
            swap(1, size--);
            sink(1);
            elements[pq[size + 1]] = null;
            qp[pq[size + 1]] = -1;
            return index;
        }
        //删除索引k及其元素
        public void delete(int k) {
            int index = qp[k];
            swap(index, size--);
            swim(index);
            sink(index);
            elements[k] = null;
            qp[k] = -1;
        }
        
        //插入元素,将它和索引k关联
        public void insert(int k, E element) {
            size++;
            qp[k] = size;
            pq[size] = k;
            elements[k] = element;
            swim(size);
        }
    
         //改变索引k关联的元素
        public void change(int k, E element) {
            elements[k] = element;
            swim(qp[k]);
            sink(qp[k]);
        }
        
        //是否包含索引k
        public boolean contains(int k) {
            return qp[k] != -1;
        }
        
        //下沉
        private void sink(int k) {
            while (2 * k <= size) {
                int j = 2 * k;
                if (j < size && less(j, j + 1))
                    j++;
                if (!less(k, j))
                    break;
                swap(k, j);
                k = j;
            }
        }
    
        //上浮
        private void swim(int k) {
            while (k > 1 && less(k / 2, k)) {
                swap(k, k / 2);
                k = k / 2;
            }
        }
        private boolean less(int i, int j) {
            return elements[pq[i]].compareTo(elements[pq[j]]) > 0;
        }
    
        //交换两元素
        private void swap(int i, int j) {
            int swap = pq[i];
            pq[i] = pq[j];
            pq[j] = swap;
            qp[pq[i]] = i;
            qp[pq[j]] = j;
        }
    }

    索引优先队列的时间复杂度:

    索引优先队列的时间复杂度

    找出最大元素的索引优先队列的JAVA版本IndexMaxPQ.java 点这里

    好了,这节就总结这么多吧。

  • 相关阅读:
    CF 444B(DZY Loves FFT-时间复杂度)
    摆弄【Nhibernate 协会制图--导乐陪伴分娩】
    固定的报文统计报告的规定
    CSS——(2)与标准流盒模型
    自动复制转换StringBuffer
    IM信息网
    Oracle Redo Log
    【转载】有哪些省时小技巧,是每个Linux用户都应该知道的
    Linux snmp
    MySQL zabbix
  • 原文地址:https://www.cnblogs.com/Leo_wl/p/5982847.html
Copyright © 2011-2022 走看看