最大优先队列:使用堆来实现
代码:
package com.chenqing.test.linearList.queue;
public class MaxPriorityQueue<T extends Comparable<T>> {
private T[] items;
private int n;
public MaxPriorityQueue(int capacity) {
items = (T[]) new Comparable[capacity + 1];
this.n = 0;
}
public int size() {
return n;
}
private boolean compare(int i, int j) {
return items[i].compareTo(items[j]) > 0;
}
private void exchange(int i, int j) {
T temp = items[i];
items[i] = items[j];
items[j] = temp;
}
public boolean isEmpty() {
return n == 0;
}
public void insert(T obj) {
items[++n] = obj;
swim(n);
}
public T delMax() {
T maxVal = items[1];
exchange(1, n);
n--;
sink(1);
return maxVal;
}
private void swim(int k) {
while (k > 1) {
if (compare(k, k / 2)) {
exchange(k, k / 2);
}
k = k / 2;
}
}
private void sink(int k) {
while (2 * k <= n) {
int max;
if (2 * k + 1 <= n) {
if (compare(2 * k, 2 * k + 1)) {
max = 2 * k;
} else {
max = 2 * k + 1;
}
} else {
max = 2 * k;
}
if (compare(k, max)) {
break;
}
exchange(k, max);
k = max;
}
}
}
最小优先队列:
package com.chenqing.test.linearList.queue;
public class MinPriorityQueue <T extends Comparable<T>>{
private T[] items;
private int n;
public MinPriorityQueue(int capacity) {
this.items = (T[]) new Comparable[capacity+1];
this.n = 0;
}
public int size(){
return n;
}
public boolean isEmpty(){
return n == 0;
}
private boolean compare(int i , int j){
return items[i].compareTo(items[j]) < 0;
}
private void exchange(int i, int j){
T temp = items[i];
items[i] = items[j];
items[j] = temp;
}
public void insert(T obj){
items[++n] = obj;
swim(n);
}
public T delMin(){
T minObj = items[1];
exchange(1, n);
n--;
sink(1);
return minObj;
}
private void swim(int k){
while (k > 1){
if(compare(k, k/2)){
exchange(k, k/2);
}
k = k/2;
}
}
private void sink(int k){
while (2*k <n ){
int min;
if(2*k+1 < n){
if(compare(2*k, 2*k+1)){
min = 2*k;
}else{
min = 2*k+1;
}
}else{
min = 2*k;
}
if(compare(k, min)){
break;
}
exchange(k, min);
k = min;
}
}
}
索引最小优先队列:不同于以上两种优先队列,此队列可以访问队列中的任意元素,对元素进行操作
package com.chenqing.test.linearList.queue;
public class IndexMinPriorityxQueue <T extends Comparable<T>>{
private T[] items;
private int[] pq;
private int[] qp;
private int n;
public IndexMinPriorityxQueue(int capacity) {
this.items = (T[]) new Comparable[capacity+1];
pq = new int[capacity+1];
qp = new int[capacity+1];
n = 0;
for (int i = 0; i < qp.length; i++) {
qp[i] = -1;
}
}
private boolean compare(int i, int j){
return items[pq[i]].compareTo(items[pq[j]]) < 0;
}
private void exchange(int i, int j){
int k = pq[i];
pq[i] = pq[j];
pq[j] = k;
qp[pq[i]] = i;
qp[pq[j]] = j;
}
public int delMin(){
int minIndex = pq[1];
exchange(1, n);
qp[pq[n]]=-1;
pq[n] = -1;
items[minIndex] = null;
n--;
sink(1);
return minIndex;
}
public void insert(T obj){
insert(n, obj);
}
public void insert(int i, T obj){
if(contains(i)){
return;
}
n = n+1;
items[i] = obj;
pq[n] = i;
qp[i] = n;
swim(n);
}
private void swim(int k){
while (k > 1){
if(compare(k, k/2)){
exchange(k, k/2);
}
k = k/2;
}
}
private void sink(int k){
while (2*k < n){
int min;
if(2*k+1 < n){
if(compare(2*k, 2*k+1)){
min = 2*k;
}else{
min = 2*k+1;
}
}else{
min = 2*k;
}
if(compare(k, min)){
break;
}
exchange(k, min);
k = min;
}
}
public int size(){
return n;
}
public boolean isEmpty(){
return n == 0;
}
public boolean contains(int k){
return qp[k] != -1;
}
public void changeItem(int i, T t){
items[i] = t;
int k = qp[i];
swim(k);
sink(k);
}
public int minIndex(){
return pq[1];
}
public void delete(int i){
int k = qp[i];
exchange(k, n);
pq[n] = -1;
qp[k] = -1;
items[i] = null;
n--;
swim(k);
sink(k);
}
}