优先级队列-堆实现

package sorts;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class PriorityQueue<T extends Comparable<T>> { // min-heap
    private List<T> heap = new ArrayList<>();
    private static final int ROOT_INDEX = 0;
    private static final int PRE_ROOT_INDEX = ROOT_INDEX - 1;
    public void offer(T obj) {
        heap.add(obj);//在最后增加一个元素
        int index = heap.size() - 1;//最后一个元素的索引
        while (index > ROOT_INDEX) {//在堆中加一个元素后,调整堆使其再成为一个堆
            index = stepUpHeap(index);//上浮
        }
    }
    private int stepUpHeap(int index) {
        int parentIndex = parent(index);//获取父节点的索引
        T element = heap.get(index);
        T parent  = heap.get(parentIndex);
        if (parent.compareTo(element) > 0) { //父节点大于儿子节点,交换
              heap.set(parentIndex, element);
              heap.set(index, parent);
              return parentIndex;  // 跳到父索引
         } else   
              return ROOT_INDEX; //不需要交换
    }
    public T poll() {
        if (isEmpty())
            throw new RuntimeException();
        int index = heap.size() - 1;//最后一个元素的索引
        T least;
        if(index==0){
           least = heap.get(index);
           heap.remove(index);
        }
        else{
            T element = heap.get(index);//取最后一个元素
            least  = heap.get(ROOT_INDEX);//取堆的根元素
            heap.set(ROOT_INDEX, element);//交换这两个元素
            heap.set(index, least);
            heap.remove(index);//删除最后一个元素
            stepDownHeap(ROOT_INDEX);//下沉调整,使之再次成为堆
         }
         return least;
    }
    private void stepDownHeap(int index) {
        int p = index;//parent
        int lchild = lchild(p);//左子节点
        T temp = heap.get(p);
        while(lchild<heap.size()){
        if(lchild+1<heap.size() && heap.get(lchild+1).compareTo(heap.get(lchild))<0)//右节点比左节点小
            lchild = lchild + 1;//取两个儿子节点中小的一个
            if(temp.compareTo(heap.get(lchild))<=0)//不需要调整了
                    break;
            else {
                 heap.set(p,heap.get(lchild));//较小的儿子节点上浮
                 p = lchild;
                 lchild = lchild(p);//继续调整
            }
        }
        heap.set(p,temp);//最后要将temp放到p
    }
    public T peek() {
        if (isEmpty())
            throw new RuntimeException();
        return heap.get(0);
    }
    public boolean isEmpty() {
        return heap.isEmpty();
    }
    public int size() {
        return heap.size();
    }
    @Override
    public String toString() {
        return heap.toString();
    }
    // index starts from 0
    private int parent(int index) {
        if (index%2==0) {
            return ( index / 2 ) - 1;
        } else {
            return index / 2;
        }
    }
    private int lchild(int index) {
        return index * 2 + 1;
    }
    private int rchild(int index) {
        return index * 2 + 2;
    }
    // test
    public static void main(String[] args) {
        Random random = new Random();
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        for (int i = 0; i < 10; i++) {
            pq.offer(random.nextInt(100));
        }
        for (int i = 0; i < 10; i++) {
            System.out.print(pq.poll() + " ");
        }
    }
}