堆排序

堆排序过程：（用到递归算法）

主函数中:

public void main(String[] args)
1. 定义初始化数组：int[] a = new int[]{.............}
2. 循环建堆 调用建堆函数：
　　for (int i = 0; i < a.length - 1; i++) {
　　　　buildMaxHeap(a, a.length - 1 - i); //建堆函数
　　　　swap(a, 0, a.length - i - 1); // 置换数据函数
　　}
3. 输出排序好的数组：System.out.println(Arrays.toString(a));

建堆函数中:

public static void buildMaxHeap(int[]data, int lastIndex){}//data: 数组 lastIndex 最后的节点
1. 从最后的一个节点的父节点开始进行循环：for(int i = (lastIndex - 1)/2; i >= 0; i--){
2. k保存正在判断的节点： int k = i：
3. 判断当前k节点的子节点存在，若存在进入循环：while(2 * k + 1 <= lastIndex>)
4. 当k节点的子节点存在时，biggerIndex储存k节点左节点索引 int biggerIndex = 2 * k + 1
5. 判断k节点的右节点是否存在， if(biggerIndex < lastIndex){
6. 若存在则比较k节点的左右节点的大小 if(data[biggerIndex]<data[biggerIndex +１])；
7. 若右节点的值比左节点的值大，则将biggerIndex的值+1（指向右节点） ： biggerIndex++
8. 将k节点的值和biggerIndex节点的值进行比较，若 k 节点的值比biggerIndex节点的值小，则交换k节点和biggerIndex节点的值,反之，break：
　　if (data[k] < data[biggerIndex]) {
　　　　// 交换他们
　　　　swap(data, k, biggerIndex);
　　　　// 将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值
　　　　k = biggerIndex;
　　} else {
　　　　break;
　　}

交换函数中:

public static void swap(int[] a , int i ,int j){}对值进行交换：
　　int temp = a[i];
　　a[i] = a[j];
　　a[j] = temp;

import java.util.Arrays;

public class HeapSort {
    public static void main(String[] args) {
        int a[] = { 1, 23, 5, 4, 8, 6, 3, 2, 1, 5, 8, 4, 4, 5, 2, 1 };
        // 循环建堆
        for (int i = 0; i < a.length - 1; i++) {
            buildMaxHeap(a, a.length - 1 - i); // 建堆函数
            swap(a, 0, a.length - i - 1); // 交换函数
        }
        System.out.println(Arrays.toString(a));
    }

    private static void buildMaxHeap(int[] data, int lastIndex) {
        // TODO Auto-generated method stub
        for (int i = (lastIndex - 1) / 2; i >= 0; i--) { // 从最后一个节点的父节点开始
            int k = i;
            // 2k+1 <= lastIndex 判断是否存在子节点
            while (k * 2 + 1 <= lastIndex) {
                int biggerIndex = 2 * k + 1;// 用biggerIndex保存k节点的左孩子的节点
                if (biggerIndex < lastIndex) {// 判断k节点的右孩子（节点）是否存在
                    if (data[biggerIndex] < data[biggerIndex + 1]) {// 若右孩子存在，判断左右孩子的值得大小
                        biggerIndex++;// 若右孩子比左孩子大，biggerIndex记录右孩子的节点值biggerIndex++
                    }
                }
                // 判断K节点的值是否小于其较大子节点（孩子）的值
                if (data[k] < data[biggerIndex]) {
                    swap(data, k, biggerIndex);// 若k节点的值小于其较大子孩子的值，交换k节点和biggerIndex节点的值
                    k = biggerIndex;// 将biggerIndex（较大子节点的索引）赋给 k
                } else {
                    // 若k节点的值不小于其较大子节点的值则break;（跳出循环）
                    break;
                }
            }
        }
    }

    private static void swap(int[] data, int i, int j) {
        // TODO Auto-generated method stub
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }
}