堆排序-java

思路

1. 数组的下标实际上就代表了二叉树的节点位置
2. 建立大顶堆的规则，就是要从最后一个叶子节点的父节点开始，依靠父节点与子节点的下表关系进行大小比较，进行调整。
3. 在中间节点的时候，有时候调整好了，但是有可能子节点与子节点的子节点发生了规则违背，此刻依然需要进行调整。也就是进行递归操作。

/**
 * 这个程序是将数组所有的元素直接构建堆
 * <p>
 * 最大堆：根是最大的，左右节点没有大小关系
 * <p>
 * 在这里最值得需要注意的点就是：buildMaxHeap(int[] arr,int len)中的len，它并不总是等于arr.length。
 * 当我们在进行堆排序的时候，在输出堆头之后进行堆的调整，再次构建堆的时候，需要的数组长度就不是arr.length
 *
 *  用数组保存元素，并按照一定条件进行排序。以求高效率实现删除最大元素和插入元素操作。
 *
 *  完全二叉树，用数组的存储形式比较好构建二叉树。
 *
 *  这个堆排序的实现算法本质还是通过数组的下标来进行调整的
 *
 *  大顶堆规则：父节点比子节点都大，左右节点之间没有大小关系
 */
public class ZZ {
    public static void main(String[] args) {
        int[] arr = {2, 1, 5, 4, 6, 3, 7};
        buildMaxHeap(arr, arr.length);
        showArr(arr);//第一次构建大顶堆的输出结果：7 6 5 4 1 3 2 
        sortHeap(arr);
        showArr(arr);//输出结果：1 2 3 4 5 6 7
    }
    //建立一个最大堆
    static void buildMaxHeap(int[] arr, int len) {//len并不总是数组的真实长度，而是你想调整的数组的长度。
        int last_node_index = len - 1;
        int parent_node_index = (last_node_index - 1) / 2;
        for (int i = parent_node_index; i >= 0; i--) {
            heapifyOne(arr, len, i);
//            heapifyOne(arr, len,i);//len并不总是数组的真实长度，而是你想调整的数组的长度。
        }
    }
    //调整为二叉堆。我自己想出来的。明显我这个花费的时间和步骤会更多。也就是相比于heapifyOne（）方法，我这个方法调整为二叉堆时候会移动更多的元素。
    static public void heapify(int[] arr, int len, int parent_node_index) {//len并不总是数组的真实长度，而是你想调整的数组的长度。
        int left_node_index = parent_node_index * 2 + 1;
        int right_node_index = parent_node_index * 2 + 2;
        if (left_node_index < len && arr[left_node_index] > arr[parent_node_index]) {
            swap(arr, left_node_index, parent_node_index);
            heapify(arr, len, left_node_index);
        }
        if (right_node_index < len && arr[right_node_index] > arr[parent_node_index]) {
            swap(arr, right_node_index, parent_node_index);
            heapify(arr, len, right_node_index);
        }
    }
    //调整为二叉堆。他人的想法
    static public void heapifyOne(int[] arr, int len, int parent_node_index) {//len//len并不总是数组的真实长度，而是你想调整的数组的长度。数组的真实长度，而是你想调整的数组的长度。
        int left_node_index = parent_node_index * 2 + 1;
        int right_node_index = parent_node_index * 2 + 2;
        int max = parent_node_index;
        if (left_node_index < len && arr[left_node_index] > arr[max]) {//易错点：这里必须写max而不是写parent_node_index。因为要确认左右子树与根的关系
            max = left_node_index;
        }
        if (right_node_index < len && arr[right_node_index] > arr[max]) {
            max = right_node_index;
        }
        if (max != parent_node_index) {
            swap(arr, max, parent_node_index);
            heapifyOne(arr, len, max);
        }
    }
    //对堆进行排序。首先将第一个顶点输出，将第一个节点与最后一个节点交换，然后调整堆
    static public void sortHeap(int[] arr) {
        int len = arr.length;
        for (int i = 0; i < len; i++) {
//            showArr(arr);//输出每次调整的堆结构
            swap(arr, 0, len - 1 - i);//交换的是坐标
//            System.out.println("调整之后的最大元素"+arr[len-1-i]);
            buildMaxHeap(arr, len - 1 - i);//建立堆：数组以及数组需要调整的长度。因为放在后面的最大元素我是不想再动的
        }
    }
    //通过下标交换数组中的两个元素
    public static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
    //输出数组的元素
    public static void showArr(int[] arr) {
        System.out.print("依次输出数组的元素：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}