【堆排序的递归实现和非递归】Java实现

1、堆是一种重要的数据结构，为一棵完全二叉树，堆排序则是借助堆的概念实现的一种排序算法。若使用数组存储数据的话，则对于数组中下标为 i 的元素，其对应的左子树的下标为 2i+1，右子树的下标为 2i+2；
2、堆可以分为大顶堆和小顶堆：
（1）大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
（2）小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；
3、堆排序的最坏、最好和平均时间复杂度都为O(nlogn)，空间复杂度为O(1)；
4、对数组进行堆排序的整体思路：
（1）先将整个数组调整为"大顶堆"或者"小顶堆"，调整是从对应的堆结构的非叶子节点开始调整，直到整个数组对应的堆结构形成大顶堆或小顶堆；
（2）将对应的堆结构中的首位进行交换，将最大数或最小数换至末尾；
（3）重新调整结构使其满足堆的定义，然后重复步骤（2）和（3），直到整个数组有序。
5、堆可应用于实现优先级队列、求TopK问题、求中位数等；
6、代码实现（以大顶堆为例）
（1）递归实现

public void heapSort(int[] arr) {
    // 将数组调整为满足对应的堆结构
    for (int i = arr.length / 2 - 1; i >= 0 ; i--)
        heapify(arr, i, arr.length);
   
    for (int i = arr.length - 1; i > 0; i--) {
        // 交换子堆的首尾元素
        swap(arr, i, 0);
        // 交换完成后重新调增堆结构，使其满足堆的定义
        heapify(arr, 0, i);
    }
}
private void heapify(int[] arr, int i, int length) {
    int maxIdx = i;	// 保存当前子堆的父节点
    int left = i * 2 + 1; // 左子节点对应的下标
    int right = i * 2 + 2; // 右子节点对应的下标

	// 找到左子节点和右子节点中的最大值
    if (left < length && arr[maxIdx] < arr[left])
        maxIdx = left;
    if (right < length && arr[maxIdx] < arr[right])
        maxIdx = right;

	// 最大值的下标不是父节点
    if (maxIdx != i) {
    	// 交换
        swap(arr, i, maxIdx);
        // 调整堆结构
        heapify(arr, maxIdx, length);
    }
}
private void swap (int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

（2）非递归实现：与递归实现方式不同之处在于调整堆，即heapify的实现，具体如下：

// 维护堆结构
public void heapify(int[] arr, int i, int length) {
	// 先记录当前调整的堆的父节点的值
    int temp = arr[i];
    // 初始化 k 指向数组中 i 至 length 之间子数组对应的堆中 i 节点的左子节点
    for (int k = 2 * i + 1; k < length; k = k * 2 + 1) {
    	// 若右子节点值比左子节点值大，则改变指向
        if (k+1 < length && arr[k] < arr[k+1])
            k++;
		
		// 若父节点的值小于子节点的最大值
        if (temp < arr[k]) {
            arr[i] = arr[k];	// 交换
            i = k;	// 将 i 指向 k， 继续调整以 k 为父节点的堆
        } else {
            break; // 直接退出
        }
    }
    // 将值最大的子节点的值赋值为之前的父节点的值
    arr[i] = temp;
}