二叉堆以及堆排序实现

二叉堆

• 二叉堆是一种特殊的完全二叉树，只不过它存储在数组中。
  （1）大顶堆：每个结点都大于等于它的两个子结点的二叉堆。
  （2）小顶堆：每个结点都小于等于它的两个子结点的二叉堆。
• 如果根结点的下标是 0，那么对于某个结点 i：
  （1）其左结点下标：2 * i + 1
  （2）其右结点的下标：2 * i + 2
  （3）其父结点的下标：(i - 1) / 2
• 大顶堆的实现：
  （1）swim()：如果堆的有序状态因为某个结点变的比它的父结点更大而被打破，那么我们就需要通过交换它和它的父结点来修复堆。交换后，这个节点比它的两个子结点都大（一个是曾经的父结点，另一个比它更小，因为它是曾经父结点的子结点），但这个结点仍然可能比它现在的父结点更大，我们可以一遍遍地用同样的方法恢复秩序。
  （2）sink()：如果堆的有序状态因为某个结点变的比它的两个子结点或是其中之一更小了而被打破，那么我们就需要通过交换它和它的两个子结点中的较大者来修复堆。交换可能会在子结点处继续打破堆的有序状态，因此我们需要不断地用相同的方式将其修复。

class BinaryHeap{
    int[] nums; // 存储元素的数组
    int n = 0; // 数组中元素的个数。nums[0 ... n - 1]
    public BinaryHeap(int maxN){
        nums = new int[maxN];
    }
    // 插入新元素
    public void insert(int num){
        // 将新元素加到最后
        nums[n++] = num;
        // 让它上浮到正确的位置
        swim(n - 1);
    }
    // 删除并返回二叉堆中的最大元素
    public int delMax(){
        // 大顶堆的堆顶就是最大元素
        int max = nums[0];
        // 将最大元素换到最后
        swap(0, n - 1);
        // 删除最大元素
        nums[n - 1] = 0;
        n--;
        // 将 nums[0] 下沉到正确的位置
        sink(0);
        return max;
    }
    // 交换 nums[i] 和 nums[j] 的值
    public void swap(int i, int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
    // 上浮
    public void swim(int k){
        // 如果浮到堆顶，就不能再上浮了
        // 如果还没浮到堆顶 && 当前结点大于当前结点的父结点
        while(k > 0 && nums[k] > nums[(k - 1) / 2]){
            swap(k, (k - 1) / 2);
            k = (k - 1) / 2;
        }
    }
    // 下沉
    public void sink(int k){
        // 如果沉到堆底，就沉不下去了
        while(2 * k + 1 <= n - 1){
            // 假设当前结点的左子结点较大
            int bigger = 2 * k + 1;
            // 如果当前结点的右子结点存在 && 当前结点的左子结点小于当前结点的右子结点
            if(bigger + 1 < n && nums[bigger] < nums[bigger + 1]){
                bigger++;
            }
            // 如果当前结点比它的左右结点中较大的那个还大，那么就不必下沉
            // 也就是说如果当前节点比它的左右结点都大，那么就不必下沉
            if(nums[k] >= nums[bigger]){
                break;
            }
            // 否则，需要下沉当前节点
            swap(k, bigger);
            k = bigger;
        }
    }
}

堆排序

package sort;

import java.util.Arrays;

public class DuiPaiXu {
    public static void main(String[] args) {
        int[] nums = {3, 7, 4, 9, 7, 2, 1, 6};
        heapSort(nums);
        System.out.println(Arrays.toString(nums));
    }
    public static void heapSort(int[] nums){
        int n = nums.length;
        // 将整个数组构造成大顶堆（从最后一个非叶子结点开始调整）
        for(int i = n / 2 - 1; i >= 0; i--){
            sink(nums, i, n);
        }
        while(n > 0){
            // 将最大的元素 nums[0] 和 最后一个元素 nums[n - 1] 交换位置
            swap(nums, 0, n - 1);
            // 将最大的元素删除
            n--;
            // 修复堆。交换了一次后堆已经不符合条件了，需要重新让它变成大顶堆
            sink(nums, 0, n);
        }
    }
    public static void sink(int[] nums, int k, int n){
        // 如果沉到堆底，就沉不下去了
        while(2 * k + 1 <= n - 1){
            // 假设当前结点的左子结点较大
            int bigger = 2 * k + 1;
            // 如果当前结点的右子结点存在 && 当前结点的左子结点小于当前结点的右子结点
            if(bigger + 1 < n && nums[bigger] < nums[bigger + 1]){
                bigger++;
            }
            // 如果当前结点比它的左右结点中较大的那个还大，那么就不必下沉
            // 也就是说如果当前节点比它的左右结点都大，那么就不必下沉
            if(nums[k] >= nums[bigger]){
                break;
            }
            // 否则，需要下沉当前节点
            swap(nums, k, bigger);
            k = bigger;
        }
    }
    public static void swap(int[] nums, int i, int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}