算法基础三:分治算法---基于二叉堆的优先队列
算法基础三:分治算法---基于二叉堆的优先队列
一、算法描述与分析
堆还有一个作为有效优先队列的应用。优先队列,指的是队列中的元素都被指派了一个优先级,元素按优先级最大(或最小)出队。由于,存储堆的数组的第一个元素就是最大的(或者最小的),所以用堆作为优先队列的元素载体是合适的。
队列有两个基本操作:
- 入队操作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();
}
}