优先级队列（堆）的原理及其实现

在很多应用中，我们通常需要按照优先级情况对待处理对象进行处理，比如首先处理优先级最高的对象，然后处理次高的对象。最简单的一个例子就是，在手机上玩游戏的时候，如果有来电，那么系统应该优先处理打进来的电话。在这种情况下，我们的数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。这种数据结构就是优先级队列(Priority Queue)

public class PriorityQueue {
    private int capacity=10;//初始容量
    private int[] array=new int[capacity];//用来盛放元素的数组
    private int size=0;//队列里有效元素的个数


    //向下调整。已知父节点坐标，父节点与两个子节点比较大小，和最小的互换位置
    private static  void shiftDown(int[] array,int size,int index){
        int left=2*index+1;
        while (left<size){
            int min=left;
            int right=2*index+2;
            if(right<size){
                if(array[right]<array[left]){
                    min=right;
                }
            }
            if(array[index]<array[min]){
                break;
            }
            int flag=array[index];
            array[index]=array[min];
            array[min]=flag;
            index=min;
            left=2*index+1;
        }

    }


    private static void createHeap(int[] array,int size){
        for(int i=(size-1)/2;i>=0;i--){
            shiftDown(array,size,i);
        }
    }


    //向上调整，已知子节点坐标，index代表当前节点，parent代表父节点，比较大小，大的在堆顶
    private static void shiftUp(int[] array,int index){
        while (index>0){
            int parent=(index-1)/2;
            if(array[parent]>=array[index]){
                break;
            }
            int flag=array[parent];
            array[parent]=array[index];
            array[index]=flag;
            index=parent;
        }
    }
    
    //当超过了当前容量，进行扩容
    private void grow(int minCapacity){
        if(minCapacity<0){
            throw new OutOfMemoryError();
        }
        int oldCapacity=array.length;
        int newCapacity=oldCapacity+oldCapacity/2;
        array=Arrays.copyOf(array,newCapacity);
    }
    
    //从堆尾开始添加元素，然后向上调整
    public boolean offer(int e){
        int i=size;
        if(i>=array.length){
            grow(capacity);
        }
        if(i==0){
            array[0]=e;
            size=i+1;
        }else {
        array[size++]=e;
        shiftUp(array,size-1);
        }
        return true;
    }
    
    //从堆顶取出元素，堆顶元素，暂时用堆尾元素替代
    public int poll(){
        int oldValue=array[0];
        array[0]=array[--size];
        shiftDown(array,size,0);
        return oldValue;
    }
    public int peek(){
        return array[0];
    }
    public String toString(){
        return  Arrays.toString(Arrays.copyOf(array,size));
    }
    public static void main(String[] args) {
        PriorityQueue queue=new PriorityQueue();
        for(int i=0;i<12;i++){
            queue.offer(i);
        }
        System.out.println(queue);
    }
}

来试试效果

[11, 9, 10, 6, 8, 5, 4, 0, 3, 2, 7, 1]

Process finished with exit code 0