堆排序

package com.yan.algorithm;

import java.util.Arrays;

public class HeapSortTest {
    /*
     * 堆得规则：任何一个parent节点都比其左右子节点大（或者小）。
     * 堆排序步骤：
     * 1.初始化堆，即从倒数第一个parent节点开始往前，进行调整，使任何一个parent节点都比其左右子节点大（或者小）。
     * 2.堆初始化后的堆进行排序，每次将堆顶节点和堆最后一个节点进行交换，并调整，循环n次。
     * 三个方法：
     * （1）初始化 heapInit()
     *         从倒数第一个parent节点开始往前，进行调整
     * （2）调整 heapify()
     *         由parent节点找到其2个子节点，并交换使得parent节点为最大，递归调整交换的子树
     * （3）排序 sort()
     *         每次将堆顶节点和堆最后一个节点进行交换，并调整，循环n次
     */

    private static int[] data = new int[] { 12, 13, 14, 46, 15, 65, 99 };

    public HeapSortTest() {
    }

    public static void main(String[] args) {

        heapInit(data, data.length);
        sort(data);
        System.out.println(Arrays.toString(data));
    }

    /**
     * 创建初始堆，若堆排序目的是为了递增排序，则初始堆是一个最大堆。
     * 
     * @param data
     * @param length为数组长度
     */
    public static void heapInit(int[] data, int length) {
        // 从最后一个parent节点开始调整。
        int start = getParentIndex(length - 1);
        // 因为从倒数第一个parent节点开始往前的每一个节点都要调整，所以要用for循环。
        for (int i = start; i >= 0; i--) {
            heapify(data, length, i);
        }
    }

    /*
     * 在parent和左右子节点3者之间交换调整，使得parent是3者中最大值.
     * heapsize是需要调整的节点数的长度，用来判断子节点是否越界（和在sort方法中设置调整的范围，因为已排序的后面一部分不需要再调整了）。
     */
    public static void heapify(int[] data, int heapsize, int start) {
        int largest = start;
        int leftChild = getLeftChildIndex(start);
        int rightChild = getRightChildIndex(start);
        if (leftChild < heapsize && data[largest] < data[leftChild]) {
            largest = leftChild;
        }
        if (rightChild < heapsize && data[largest] < data[rightChild]) {
            largest = rightChild;
        }
        /*
         * 如果发生了交换，则该子节点的子树也不再符合堆的规则。 因此，需要继续对其子节点进行递归调整。
         */
        if (largest != start) {
            swap(data, start, largest);
            heapify(data, heapsize, largest);
        }

    }

    /**
     * 对初始化过的堆进行排序（将最大堆排序为递增堆 “即，每次将堆顶元素和堆末尾的元素进行交换，然后从堆顶元素开始进行调整”，
     * 或者将最小堆排序为递减堆。“即，同上”）
     * 
     * @param data
     */
    public static void sort(int[] data) {
        for (int i = data.length - 1; i > 0; i--) {
            swap(data, i, 0);
            heapify(data, i, 0);
        }
    }

    public static void swap(int[] data, int x, int y) {
        int temp = data[x];
        data[x] = data[y];
        data[y] = temp;
    }

    public static int getLeftChildIndex(int parent) {
        return (parent << 1) + 1;
    }

    public static int getRightChildIndex(int parent) {
        return (parent << 1) + 2;
    }

    public static int getParentIndex(int child) {
        return (child - 1) >> 1;
    }

}