利用无序数组实现优先队列并排序数组——ADT实现

优先队列的实现有多中实现方法，下面给出利用无序数组实现优先队列并排序数组：

/*****************************抽象数据类型***********************/

package pk.adt;
public interface ComparisonKey {
int compareTo(ComparisonKey value);
String toString();
}

package pk.adt2;
import pk.adt.ComparisonKey;
public class PQItem implements ComparisonKey {
private int key;
public PQItem(int value) {
key = value;
}
public String toString() {
return Integer.toString(key);
}
public int compareTo(ComparisonKey value) {
int a = this.key;
int b = ((PQItem) value).key;
return ((a == b) ? 0 : ((a > b) ? 1 : -1));
}
}

/*****************************优先队列的定义***********************/

package pk.priorityQueue;
import pk.adt.*;
public class PriorityQueue {
private int count;//优先队列中的元素数目
private int capacity;//可用数组位置的数目
private int capacityIncrement;//增量
private ComparisonKey[] itemArray;//含有PQ元素的数组
public PriorityQueue() {
count = 0;
capacity = 10;
capacityIncrement = 5;
itemArray = new ComparisonKey[capacity];
}
public int size() {
return count;
}
public void insert(ComparisonKey newItem) {
if (count == capacity) {//itemArray长度不够时，扩展增量
capacity += capacityIncrement;
ComparisonKey[] tempArray = new ComparisonKey[capacity];
for (int i = 0; i < count; i++) {
tempArray[i] = itemArray[i];
}
tempArray = itemArray;
}
itemArray[count++] = newItem;
}
public ComparisonKey remove() {
if (count == 0) {
return null;
} else {
int maxPosition = 0;
ComparisonKey maxItem = itemArray[0];
for (int i = 0; i < count; i++) {//找到优先级最高的元素的位置
if (itemArray[i].compareTo(maxItem) > 0) {
maxPosition = i;
maxItem = itemArray[i];
}
}
itemArray[maxPosition] = itemArray[--count];//将末端元素移至删除最高优先级元素所造成的空位置
return maxItem;
}
}
}

/*****************************测试案例Applet***********************/

package pk.applet;
import java.applet.Applet;
import pk.adt.*;
import pk.adt2.*;
import pk.priorityQueue.*;
public class PQApplet extends Applet {
/**
* 
*/
private static final long serialVersionUID = 1L;
public void init() {
int n = 10;
ComparisonKey[] A = new ComparisonKey[n];
for (int i = 0; i < n; i++) {
A[i] = new PQItem(square(3 * i - 13));
}
System.out.println();
priorityQueueSort(A);//对数组A进行排序
for (int i = 0; i < n; i++) {
System.out.print(A[i] + ",");
}
}
public int square(int x) {
return x * x;
}
public void priorityQueueSort(ComparisonKey[] A) {
int i;
int n = A.length;
PriorityQueue PQ = new PriorityQueue();
for (i = 0; i < n; i++) {
PQ.insert(A[i]);//PQ为空队列，将数组中无序元素插入队列PQ中
}
for (i = n - 1; i >= 0; i--) {
A[i] = PQ.remove();//将队列PQ中的元素按优先级删除，并把删除元素排序插入数组A中
}
}
}

性能分析：

利用无序数组实现优先队列时，插入元素很简单，直接在PQ类型的队列（数组）的尾部插入一个新的元素。而删除元素的时候，我们必须找到优先级最高的那个元素，然后在删除，最后将末端元素移至删除最高优先级元素所造成的空位置。删除元素是平均需要移动一半的元素，插入操作需要O(1)的时间，而删除操作需要O(N)的时间。若用有序链表实现优先队列，则插入操作需要O(N)的时间，而删除操作需要O(1)的时间。