算法基础三：分治算法---基于二叉堆的优先队列

算法基础三：分治算法---基于二叉堆的优先队列

一、算法描述与分析

​ 堆还有一个作为有效优先队列的应用。优先队列，指的是队列中的元素都被指派了一个优先级，元素按优先级最大(或最小)出队。由于，存储堆的数组的第一个元素就是最大的(或者最小的)，所以用堆作为优先队列的元素载体是合适的。

​ 队列有两个基本操作：

• 入队操作ENQUEUE(Q,e)，其中参数Q是优先队列，e是要加入队列的元素。
• 出队操作DEQUEUE(Q)，它将返回Q中优先级最大(最小)的元素。

下面讨论利用最大堆的最大优先队列Q，假定Q是一个最大堆。

1、入队算法描述与分析

​ 对于入队的操作，我们把要加入的元素放在堆的末尾，然后维护堆的性质——从新的末尾开始，若检测到当前元素的优先级大于其父亲节点元素的优先级，两者互换。ENQUEUE

伪代码描述

ENQUEUE(Q,e)
	if heap-size[Q] = length[Q]	//堆的空间已经满了(数组没有多余的空间了)
		then error "堆上溢"
	i <- heap-size[Q] <- heap-size[Q] + 1	//如果堆空间没有满，更新heap-size(已经入堆的元素)
	A[heap-size[Q]] <- e			//把元素放在队的最后面
	while i > 1 and A[PARENT(i)] < A[i]	//从新的末尾开始，若检测到当前元素的优先级大于其父亲节点元素的优先级，两者互换
		do exchange A[i] <-> A[PARENT(i)]
			i <- PARENT(i)

2、出队算法描述与分析

​ 对于出队操作，只要将堆Q中的最大元素(Q[1])“舍弃”：Q[1]的值暂存于max，将Q[heap-size[Q]]赋予Q[1]，并使得heap-size减小1.然后维护剩余元素的堆性质，并返回max。

伪代码描述

DEQUEUE(Q)
	if heap-size[Q] < 1
		then error "堆下溢"
	max <- Q[q]
	Q[1] <- Q[heap-size[Q]]
	heap-size[Q] <- heap-size[Q] - 1
	MAX-HEAPIFY (Q,1)
	return max

二、自编程序实现版本

1、算法代码

​ 利用上一节开发的程序，来实现本次的优先队列类PrioQueue;

import java.util.Collections;
import java.util.Comparator;
import java.util.Vector;

public class PrioQueue {

    private Vector<Comparable> heap;
    private int heapSize;
    Comparator comparator;
    public PrioQueue(){
        heapSize = 0;
        heap = new Vector<Comparable>();
        comparator = new Greater();
    }

    public PrioQueue(Comparator comp){
        heapSize = 0;
        heap = new Vector<Comparable>();
        comparator = comp;
    }

    public void enQueue (Comparable e){
        int i = heapSize++;//进入队列加一
        heap.add(e);
        while ((i>0) && (comparator.compare(heap.get(i),heap.get(LinearList.parent(i))) > 0)){
            Collections.swap(heap,LinearList.parent(i),i);
            i = LinearList.parent(i);
        }
    }

    public Comparable deQueue(){
        if (heapSize<1)
            return null;
        Comparable top = heap.get(0);//top <- heap[0]
        heapSize--;
        heap.set(0,heap.get(heapSize)); //heap[0] <- heap[heapSize]
        heap.remove(heapSize); //将heap[heapSize]从heap中删除
        LinearList.heapify(heap,0,heapSize,comparator);
        return top;
    }

    public boolean empty(){
        return heapSize <= 0;
    }
}

2、测试代码

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Vector;

public class TestPrioQueue {
    public static void main(String[] args) {
        Integer a[] = {5,1,9,4,6,2,0,3,8,7},i;
        String b[] = {"ChongQing","ShangHai","AoMen","TianJin","BeiJing","XiangGang"};
        Double c[] = {8.5,6.3,1.7,9.2,0.5,2.3,4.1,7.4,5.9,3.7};

        PrioQueue q = new PrioQueue();
        PrioQueue q1 = new PrioQueue(new Less());
        PrioQueue q2 = new PrioQueue(new Greater());

        for (i=0;i<10;i++){
            q.enQueue(a[i]);
            q2.enQueue(c[i]);
        }

        for (i=0;i<6;i++)
            q1.enQueue(b[i]);

        while (!q.empty())
            System.out.print(q.deQueue()+" ");
        System.out.println();

        while (!q1.empty())
            System.out.print(q1.deQueue()+" ");
        System.out.println();

        while (!q2.empty())
            System.out.print(q2.deQueue()+" ");
        System.out.println();

    }
}

三、Collection Framework的PriorityQueue类

​ Java提供了一个优先队列类PriorityQueue，该类定义在包Java.util中，它有两个构造方法：默认的构造方法PriorityQueue()，创建一个空的最小优先队列；PriorityQueue (int n, Comparator comparator)使用比较规则comparator创建一个可以容纳n个元素的优先队列

测试代码

import java.util.PriorityQueue;

public class TestPrioQueue_2 {
    public static void main(String[] args) {
        Integer a[] = {5,1,9,4,6,2,0,3,8,7},i;
        PriorityQueue q = new PriorityQueue(10, new Less());
        PriorityQueue q1 = new PriorityQueue();
        for (i=0;i<10;i++){
            q.add(a[i]);
            q1.add(a[i]);
        }

        while (!q.isEmpty())
            System.out.print(q.poll() + " ");
        System.out.println();

        while (!q1.isEmpty())
            System.out.print(q1.poll()+" ");
        System.out.println();

    }
}