java堆排序

思路：
1.首先将数组转换成大顶堆，从最后一个非叶子节点开始向根节点遍历，可以通过ints.length / 2 - 1来确定最后一个非叶子节点，依次将最大的节点调整到父节点，如果当前节点的被交换到父节点的子节点时子树的话再调整这个子树
2.将根节点那出来，因为当前根节点时最大的，然后将最后一个节点移动到根节点，然后比较根节点与子节点的大小，进行更换，并依次调整被交换的子树例如左子节点比根节点大，交换左子节点与根节点，然后再调节左子树

代码：

package com.wangyq.datastructrue.sort;

import java.util.Arrays;

public class HeapSort {
    public static void main(String[] args) {
        int[] ints = {65, 64, 561, 213, 5479, 87465, 13, 9, 7984, 31, 6874, 51, 321, 84, 651, 23, 68, 56, 52, 416, 1, 3, 464, 68, 4, 6};
        //将数组转换为大顶堆
        changeHeap(ints);
        //根据大小交换子节点
        heapSort(ints);
    }

    private static void heapSort(int[] ints) {
        //确定最后一个节点开始排序
        for (int i = 0; i < ints.length; i++) {
            int temp = ints[0];
            ints[0] = ints[ints.length - i - 1];
            ints[ints.length - i - 1] = temp;
            switchingNode(0, ints, ints.length - i - 1);
        }
        System.out.println("排序后：" + Arrays.toString(ints));
    }


    private static void changeHeap(int[] ints) {
        //确定最后一个非叶节点开始排序
        int index = ints.length / 2 - 1;
        //对节点进行交换
        for (; index >= 0; index--) {
            switchingNode(index, ints);
        }
        System.out.println("大顶堆数：" + Arrays.toString(ints));

    }

    private static void switchingNode(int index, int[] ints) {
        switchingNode(index, ints, ints.length);
    }

    /**
     * 将大于根节点的值交换上去
     *
     * @param index  根节点位置
     * @param ints   排序的数组
     * @param length 计算的长度
     */
    private static void switchingNode(int index, int[] ints, int length) {
        //记录当前子树根节点值
        int num1 = ints[index];
        //被交换的子节点
        Integer changeIndex = num1;
        Integer num2 = null;
        //取左右两个节点的值
        //左节点
        if (index * 2 + 1 < length) {
            num2 = ints[index * 2 + 1];
            changeIndex = index * 2 + 1;
        }
        //右节点
        if (index * 2 + 2 < length) {
            int num3 = ints[index * 2 + 2];
            if (num3 > num2) {
                //和左节点比较大小
                num2 = num3;
                changeIndex = index * 2 + 2;
            }
        }
        //比较根节点和子结点中大的值
        if (num2 != null && num2 > num1) {
            ints[index] = num2;
            ints[changeIndex] = num1;
            switchingNode(changeIndex, ints, length);
        }
    }
}

执行结果：
大顶堆数：[87465, 7984, 651, 213, 6874, 561, 84, 68, 64, 416, 5479, 68, 321, 65, 13, 23, 9, 56, 52, 31, 1, 3, 464, 51, 4, 6]
排序后：[1, 3, 4, 6, 9, 13, 23, 31, 51, 52, 56, 64, 65, 68, 68, 84, 213, 321, 416, 464, 561, 651, 5479, 6874, 7984, 87465]