第六章 堆排序

以后尽量能用迭代就别用递归啊，递归只是让自己轻松了，但是却增加了电脑的负担。

package chap06_Heap_Sort;



import static org.junit.Assert.*;



import java.util.Arrays;



import org.junit.Test;



public class SortAlorithms {

    /**

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

     * 

     * @param i

     * @return

     */

    protected static int parent(int i) {

        if (i == 0)

            return i;

        return (i - 1) / 2;

    }



    /**

     * 返回i的对应左子节点下标

     * 

     * @param i

     * @return

     */

    protected static int left(int i) {

        return 2 * i + 1;

    }



    /**

     * 返回i对应右子节点下标

     * 

     * @param i

     * @return

     */

    protected static int right(int i) {

        return 2 * (i + 1);

    }



    /**

     * 维护最大堆性质(递归方法实现) 容易内存溢出

     * 

     * @param a

     * @param i

     */

    protected static void maxHeapify1(int[] a, int i, int SIZE) {

        int l = left(i);

        int r = right(i);

        int tmp;

        if (l < SIZE & r < SIZE) {

            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;

            }

        } else if (l < SIZE) {

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

                tmp = a[i];

                a[i] = a[l];

                a[l] = tmp;

                i = l;

            }

        } else {

            return;

        }

        maxHeapify1(a, i, SIZE);

    }



    /**

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

     * 

     * @param a

     * @param i

     * @param SIZE

     */

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

        int l = left(i);

        int r = right(i);

        int tmp;

        while (l < SIZE & r < SIZE) {

            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 < SIZE) {

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

                tmp = a[i];

                a[i] = a[l];

                a[l] = tmp;

                i = l;

            }

        }

        return;

    }



    /**

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

     * 

     * @param a

     */

    protected static void buildMaxHeap(int[] a) {

        int n = a.length;



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

            maxHeapify1(a, i, n);

        }

    }



    /**

     * 堆排序

     * 

     * @param n

     */

    static void heapSort(int[] n) {

        buildMaxHeap(n);

        int l = n.length;

        int size = l;

        int tmp;

        for (int i = l - 1; i > 0; i--) {

            tmp = n[0];

            n[0] = n[i];

            n[i] = tmp;

            size--;

            maxHeapify(n, 0, size);

        }

    }



    @Test

    public void testName() throws Exception {

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

        int[] a = { 4, 1, 3, 2, 16, 9, 10, 14, 8, 7 };

        // buildMaxHeap(a);

        // heapSort(a);

        maxHeapify1(a, 0, 10);

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

    }

}