优先级队列-堆实现

  1 package sorts;

  2 

  3 import java.util.ArrayList;

  4 import java.util.List;

  5 import java.util.Random;

  6 

  7 public class PriorityQueue<T extends Comparable<T>> { // min-heap

  8     private List<T> heap = new ArrayList<>();

  9     private static final int ROOT_INDEX = 0;

 10     private static final int PRE_ROOT_INDEX = ROOT_INDEX - 1;

 11     public void offer(T obj) {

 12         heap.add(obj);//在最后增加一个元素

 13         int index = heap.size() - 1;//最后一个元素的索引

 14         while (index > ROOT_INDEX) {//在堆中加一个元素后,调整堆使其再成为一个堆

 15             index = stepUpHeap(index);//上浮

 16         }

 17     }

 18     private int stepUpHeap(int index) {

 19         int parentIndex = parent(index);//获取父节点的索引

 20         T element = heap.get(index);

 21         T parent  = heap.get(parentIndex);

 22         if (parent.compareTo(element) > 0) { //父节点大于儿子节点,交换

 23               heap.set(parentIndex, element);

 24               heap.set(index, parent);

 25               return parentIndex;  // 跳到父索引

 26          } else   

 27               return ROOT_INDEX; //不需要交换

 28     }

 29     public T poll() {

 30         if (isEmpty())

 31             throw new RuntimeException();

 32         int index = heap.size() - 1;//最后一个元素的索引

 33         T least;

 34         if(index==0){

 35            least = heap.get(index);

 36            heap.remove(index);

 37         }

 38         else{

 39             T element = heap.get(index);//取最后一个元素

 40             least  = heap.get(ROOT_INDEX);//取堆的根元素

 41             heap.set(ROOT_INDEX, element);//交换这两个元素

 42             heap.set(index, least);

 43             heap.remove(index);//删除最后一个元素

 44             stepDownHeap(ROOT_INDEX);//下沉调整,使之再次成为堆

 45          }

 46          return least;

 47     }

 48     private void stepDownHeap(int index) {

 49         int p = index;//parent

 50         int lchild = lchild(p);//左子节点

 51         T temp = heap.get(p);

 52         while(lchild<heap.size()){

 53         if(lchild+1<heap.size() && heap.get(lchild+1).compareTo(heap.get(lchild))<0)//右节点比左节点小

 54             lchild = lchild + 1;//取两个儿子节点中小的一个

 55             if(temp.compareTo(heap.get(lchild))<=0)//不需要调整了

 56                     break;

 57             else {

 58                  heap.set(p,heap.get(lchild));//较小的儿子节点上浮

 59                  p = lchild;

 60                  lchild = lchild(p);//继续调整

 61             }

 62         }

 63         heap.set(p,temp);//最后要将temp放到p

 64     }

 65     public T peek() {

 66         if (isEmpty())

 67             throw new RuntimeException();

 68         return heap.get(0);

 69     }

 70     public boolean isEmpty() {

 71         return heap.isEmpty();

 72     }

 73     public int size() {

 74         return heap.size();

 75     }

 76     @Override

 77     public String toString() {

 78         return heap.toString();

 79     }

 80     // index starts from 0

 81     private int parent(int index) {

 82         if (index%2==0) {

 83             return ( index / 2 ) - 1;

 84         } else {

 85             return index / 2;

 86         }

 87     }

 88     private int lchild(int index) {

 89         return index * 2 + 1;

 90     }

 91     private int rchild(int index) {

 92         return index * 2 + 2;

 93     }

 94     // test

 95     public static void main(String[] args) {

 96         Random random = new Random();

 97         PriorityQueue<Integer> pq = new PriorityQueue<>();

 98         for (int i = 0; i < 10; i++) {

 99             pq.offer(random.nextInt(100));

100         }

101         for (int i = 0; i < 10; i++) {

102             System.out.print(pq.poll() + " ");

103         }

104     }

105 }