第六章 堆排序 6.5 优先队列

package chap06_Heap_Sort;



import static org.junit.Assert.*;



import java.util.ArrayList;

import java.util.Arrays;



import org.junit.Test;



/**

 * 优先队列，二叉堆数组实现，数组的size最好大一些，至少比里面的堆大一些，来实现堆的扩展（插入元素）

 * 

 * @author xiaojintao

 * 

 */

public class PriorityQueue {



    /**

     * 返回当前下标下父节点的下标

     * 

     * @param i

     * @return

     */

    protected static int parent(int i) {

        if (i == 0)

            return i;

        return (i - 1) / 2;

    }



    /**

     * 

     * @param i

     * @return

     */

    protected static int left(int i) {

        return 2 * i + 1;

    }



    /**

     * 

     * @param i

     * @return

     */

    protected static int right(int i) {

        return 2 * (i + 1);

    }



    /**

     * 重建最大堆，从i开始到size（不包含size索引），size为堆的大小

     * 

     * @param a

     * @param i

     * @param size

     */

    protected static void maxHeapify(int[] a, int i, int heapsize) {

        int l = left(i);

        int r = right(i);

        int tmp;

        while (l < heapsize & r < heapsize) {

            if (a[i] >= a[l] & a[i] >= a[r])

                return;

            else if (a[l] > a[r]) {

                tmp = a[i];

                a[i] = a[l];

                a[l] = tmp;

                i = l;

            } else {

                tmp = a[i];

                a[i] = a[r];

                a[r] = tmp;

                i = r;

            }

            l = left(i);

            r = right(i);

        }

        if (l < heapsize) {

            if (a[i] < a[l]) {

                tmp = a[i];

                a[i] = a[l];

                a[l] = tmp;

                i = l;

            }

        }

        return;

    }



    /**

     * 

     * @param a

     * @return

     */

    static int heapMaximum(int[] a) {



        return a[0];

    }



    /**

     * 

     * @param a

     * @param heapsize

     * @return

     */

    static int heapExtractMax(int[] a, int heapsize) {

        if (heapsize < 1)

            return -1;

        int max = a[0];

        a[0] = a[heapsize];

        heapsize--;

        maxHeapify(a, 0, heapsize);

        return -1;

    }



    /**

     * 将数组a转换成最大堆,不要用递归方法，尽量用迭代方法实现

     * 

     * @param a

     */

    protected static void buildMaxHeap(int[] a) {

        int n = a.length;



        for (int i = n / 2; i >= 0; i--) {

            maxHeapify(a, i, n);

        }

    }



    /**

     * 将堆上x位置处的值增加为key

     * 

     * @param a

     * @param x

     * @param key

     */

    static void heapIncreaseKey(int[] a, int x, int key) {

        a[x] = key;

        if (x == 0)

            return;

        int i;

        int tmp;

        do {

            i = parent(x);

            if (a[i] >= a[x])

                break;

            else {

                tmp = a[i];

                a[i] = a[x];

                a[x] = tmp;

                x = i;

            }

        } while (i != 0);



    }



    /**

     * 向堆中插入元素，size为当前堆的尺寸,插入后，空位置处为int的最小值，min_value

     * 

     * @param n

     * @param size

     * @param key

     */

    static void maxHeapInsert(int[] n, int key, int heapsize) {

        if (heapsize == n.length)

            System.err.println("heap is full");

        heapsize++;

        n[heapsize-1] = key;

        buildMaxHeap(n);



    }



    @Test

    public void testName() throws Exception {

        int[] a = { 2, 5, 3, 7, 8, 12, 0, 2, 45, 32 };

        int[] a1 = new int[12];

        for (int i = 0; i < a1.length; i++) {

            if (i < a.length)

                a1[i] = a[i];

            else

                a1[i] = Integer.MIN_VALUE;

        }

        System.out.println(Arrays.toString(a1));

        // heapIncreaseKey(a, 3, 50);

        maxHeapInsert(a1, 65, 10);

        System.out.println(Arrays.toString(a1));

    }

}