import java.util.Arrays;

/**
 * 時間復雜度 logn
 * @author liyhu
 *
 */
public class PriorityQueue {

    private int[] array;
    private int size;
    public PriorityQueue() {
        super();
        array=new int[32];
    }
    /**
     * 
     * @Description: （入隊） 
     * @author: liyhui
     * @date: 2018年11月24日
     * 
 
@param key
     */
    private void enQueue(int key) {
        //隊列長度超出範圍，擴容
        if(size >= array.length) {
            resize();
        }
        array[size++]=key;
        upAdjust();
    }
    /**
     * 
     * @Description: （出隊） 
     * @author: liyhui
     * @date: 2018年11月24日
     * @return
 

     */
    private int deQueue() {
        if(size < 0) {
            throw new RuntimeException("the queue is empty");
        }
        //獲取堆頂元素
        int head=array[0];
        //最後一個元素移動到堆頂
        array[0]=array[--size];
        downAdjust();
        return head;
    }
    /**
     * 
     * @Description: （下沈） 
     * 
 
@author: liyhui
     * @date: 2018年11月24日
     */
    private void downAdjust() {
        int parentIndex=0;
        //temp 保存插入的父節點值，用於最後賦值
        int temp=array[parentIndex];
        int childIndex=1;
        while(childIndex < size) {
            //如果有右孩子，且右孩子大於左孩子的值，則定位到右孩子
            if(childIndex +1 < size && array[childIndex+1] > array[childIndex] ) {
                childIndex++;
            }
            //如果父節點大於任何一個孩子的值，直接跳出
            if(temp > array[childIndex]) {
                break;
            }
            //無需真正交換，單向賦值即可、
            array[parentIndex]=array[childIndex];
            parentIndex=childIndex;
            childIndex= childIndex << 1 + 1;
        }
        array[parentIndex]=temp;
    }
    /**
     * 
     * @Description: （上浮） 
     * @author: liyhui
     * @date: 2018年11月24日
     */
    private void upAdjust() {
        int childIndex=size-1;
        int parentIndex=childIndex/2;
        //temp 保存插入的葉子節點值，用於最後賦值
        int temp=array[childIndex];
        while(childIndex > 0 && temp > array[parentIndex]) {
            //無需真正交換，單向賦值即可
            array[childIndex]=array[parentIndex];
            childIndex=parentIndex;
            parentIndex=parentIndex >> 1;
        }
        array[childIndex]=temp;
    }
    /**
     * 
     * @Description: （擴容） 
     * @author: liyhui
     * @date: 2018年11月24日
     */
    private void resize() {
        // 隊列容量翻倍
        int newSize=this.size << 1;
        this.array=Arrays.copyOf(this.array, newSize);        
    }
    public static void main(String[] args) {
        
        PriorityQueue queue=new PriorityQueue();
        queue.enQueue(3);
        queue.enQueue(5);
        queue.enQueue(10);
        queue.enQueue(2);
        queue.enQueue(7);
        System.out.println("出隊元素："+queue.deQueue());
        System.out.println("出隊元素："+queue.deQueue());
    }
    
}

優先隊列代碼實現