初级排序算法之堆排序

堆排序的思想

堆排序的具体算法，思想是每次取出堆的最顶层根节点，即数组下标为0，然后与最后一个节点即i+1交换。
参考地址

建堆过程：

1. 首先将原始队列构建成完全二叉树
2. 然后从第一个非叶子节点开始，比较当前节点和其孩子节点，将最大的元素放在当前节点，交换当前节点和最大节点元素。
   注意：如果根节点是a[0]，那么第一个非叶子节点就是倒数第二层的最后一个根节点，下标为length/2-1
3. 将当前元素前面所有的元素都进行2的过程，这样就生成了最大堆

   /**
     * @param data 原始数组序列
     * @brief 构建堆
     */
    public static void buildHeap(int[] data) {
        /**
         * 获取最后一个非叶子节点
         */
        int begin = data.length / 2;
        for (int i = begin; i >= 0; i--) {
            adjustHeap(data, data.length, i);
        }
    }

    /**
     * @param data     要调整的数组
     * @param heapSize 长度
     * @param index    需要调整的节点的下标
     * @brief 调整堆
     */
    public static void adjustHeap(int[] data, int heapSize, int index) {

        /**
         * 节点index的左孩子下标
         */
        int leftChildSubscript = 2 * index + 1;
        /**
         *节点index的右孩子下标
         */
        int rightChildSubscript = 2 * index + 2;

        /**
         * 最大元素的初始下标
         */
        int largestSubscript = index;
        /**
         * 找到最大元素
         */
        /**
         * 如果当前根节点小于左孩子的值，那么最大元素的下标为左孩子的下标.
         */
        if ((leftChildSubscript < heapSize) && (data[largestSubscript] < data[leftChildSubscript])) {
            largestSubscript = leftChildSubscript;
        }
        /**
         *如果当前根节点小于右孩子的值，那么最大元素的下标为右孩子的下标.
         */
        if ((rightChildSubscript < heapSize) && (data[largestSubscript] < data[rightChildSubscript])) {
            largestSubscript = rightChildSubscript;
        }

        /**
         * 将最大元素调整至根节点.
         * 根节点不是最大的，那么就调整.
         */
        if (index != largestSubscript) {
            /**
             * 将根节点的值与子节点中的最大值进行调整.
             */
            swapElements(data, index, largestSubscript);
            /**
             */
            adjustHeap(data, heapSize, largestSubscript);
        }
    }

    public static void swapElements(int[] data, int index1, int index2) {
        int temp = data[index1];
        data[index1] = data[index2];
        data[index2] = temp;
    }

堆排序的过程：
首先将原始序列构建为一个堆。

1. 将堆顶元素和最后一个元素交换，列表长度减1。由此无序区减1，有序区加1
2. 剩余元素重新调整建堆
3. 继续1和2，直到所有元素都完成排序

    /**
     * @param data 原始数组
     * @brief 堆排序
     */
    public static void heapSort(int[] data) {
        int length = data.length;
        /**
         * 构建堆
         */
        buildHeap(data);
        while (length >= 1) {
            /**
             * 将堆的最后一个元素与堆顶元素交换.
             */
            swapElements(data, 0, length - 1);

            length--;
            /**
             * 将剩余元素调整为堆
             */
            adjustHeap(data, length, 0);
        }
    }

时间复杂度分析

建堆的时间复杂度最差为$O(N)$，最好为$O(1)$

堆排序的时间复杂度是$O(NlogN)$

堆排序为原地排序，空间复杂度为$O(1)$