最大优先序列的java实现

public class Priority_Queue {
    private static int heap_size = 0;

    public static int Parent(int i){
        return (i-1)/2;
    }

    public static void Max_Heapify(double[] A, int i){
        int l = 2*i + 1;
        int r = 2*i + 2;
        int largest;
        if (l <= heap_size - 1 && A[l] > A[i]){
            largest = l;
        }else {
            largest = i;
        }
        if (r <= heap_size - 1 && A[r] > A[largest]){
            largest = r;
        }
        if (largest != i){
            double x = A[i];
            A[i] = A[largest];
            A[largest] = x;
            Max_Heapify(A, largest);
        }
    }

    public static void Build_Max_Heapify(double[] A){
        heap_size = A.length;
        for (int i = A.length/2; i >= 0; i--){
            Max_Heapify(A, i);
        }
    }

    /**
     * 堆排序
     * @param A
     */
    public static void Heap_Sort(double[] A){
        heap_size = A.length;
        Build_Max_Heapify(A);
        for (int i = A.length - 1; i >= 1; i--){
            double x = A[0];
            A[0] = A[i];
            A[i] = x;
            heap_size--;
            Max_Heapify(A, 0);
        }
    }

    /**
     * 返回堆A中具有最大关键字的元素
     * @param A A必须已经是最大堆
     * @return
     */
    public static double Heap_Maximum(double[] A){
        return A[0];
    }

    /**
     * 去掉并返回A中的具有最大关键字的元素
     * @param A A必须已经是最大堆
     * @return
     * @throws Exception
     */
    public static double Heap_Extract_Max(double[] A) throws Exception{
        if (heap_size < 1){
            throw new Exception("heap underflow");
        }
        double max = A[0];
        A[0] = A[heap_size - 1];
        heap_size--;
        Max_Heapify(A,0);
        return max;
    }

    /**
     * 将元素A[i]的关键字增加到key
     * @param A A必须已经是最大堆
     * @param i
     * @param key
     * @throws Exception
     */
    public static void Heap_Increase_Key(double[] A, int i, double key) throws Exception{
        if (key < A[i]){
            throw new Exception("new key is smaller than current key");
        }
        A[i] = key;
        while (i > 0 && A[Parent(i)] < A[i]){
            double x = A[i];
            A[i] = A[Parent(i)];
            A[Parent(i)] = x;
            i = Parent(i);
        }
    }

    /**
     * 把元素key插入到最大堆A中
     * @param A A必须已经是最大堆
     * @param key
     * @throws Exception
     */
    public static void Max_Heap_Insert(double[] A, double key) throws Exception{
        heap_size--;
        A[heap_size] = -10000000;
        Heap_Increase_Key(A, heap_size, key);
    }

    public static void print(double[] A){
        for (int i = 0; i < A.length; i++){
            System.out.print(A[i] + " ");
        }
        System.out.println();
    }

    public static double[] copy_array(double[] A){
        double[] B = new double[A.length];
        for (int i = 0; i < A.length; i++){
            B[i] = A[i];
        }
        return B;
    }

    public static void main(String[] args) throws Exception{
        double[] A = {12, 51, 54, 2, 51, 32, 35, 26, 78, 96, 20, 34, 56, 41, 72, 100, 34, 8, 61, 94, 52, 10};
        double[] B = copy_array(A);
        Heap_Sort(B);
        System.out.print("Insertion_Sort: ");
        print(B);
        B = copy_array(A);
        Build_Max_Heapify(B);
        print(B);
        System.out.println(Heap_Maximum(B));
        System.out.println(Heap_Extract_Max(B));
        print(B);
    }
}