Heap和Heapify-CSDN博客

最近复习数据结构，又回去再看塞神的课件，看到PriorityQueue的实现。自己也根据塞神的代码写一写。

下面使用Binary Heap实现了一个简单的 Max-oriented PriorityQueue。

这里Binary Heap我们使用的是array represetation，数组形式。
1. 第0个元素我们留空，从第一个元素开始存储，第一个元素也将是PQ里最大的元素。
2. 特点是假如父节点位置是 k，那么两个子节点的位置就是 2 * k 和 2 * k + 1。这样很方便计算，知道父节点很容易计算出子节点，知道子节点的位置也能立刻知道父节点的位置。
3. Max Heap服从Max heap order，即父节点的值永远大于等于子节点的值。 (但父节点的sibling可以不大于当前父节点的子节点值)
4. 元素最好是implements Comparable[]，否则我们还要另外写Comparator<>()
一开始的构造方法里，我们为简便使用了一个定长的数组。正常来说应该使用一个resizing array，以及一个load factor。
1. 当load factor，也就是元素数 N / 数组长度 len = 0.75的时候，我们把数组扩容一倍，然后把之前的元素拷贝进去
2. 当load factor < 0.25的时候，我们把数组减半，也要拷贝之前的元素。
主要的一些方法有insert()，peek(), delMax()以及isEmpty()，为了测试我也放入了一些其他方法，比如shuffle()， heapify()，和heapSort()，下面一点点来分析各个方法。
1. insert(): 每次添加元素的时候，我们都先增加PQ中元素的个数，即++N，然后把新元素x放在数组中新的这个位置上。接下来我们调用swim()方法来使PQ依然保持有序。总复杂度是O(logn)
2. swim(): 向上维护heap order。当我们发现，或者不确定数组中一个位置的元素是否符合Max heap order时，我们需要对这个位置的值进行一个swim()操作。只用考虑子节点和父节点，不用考虑sibling.
  1. 主要操作就是将这个子节点和其父节点进行比较，假如这个位置为k的子节点的值大于其父节点，我们交换这两个节点
  2. 继续比较交换后的子节点和其新的父节点，这个可以通过 k /= 2来完成。
  3. 遍历在 k > 1的条件下进行。因为 k > 1的时候， k / 2最大就是1，也就是我们的最大节点
  4. 每次insert的时候我们可以使用swim()来保持heap order
3. peek(): 我们可以直接返回最大节点elements[1]，注意一些边界条件，或者这个节点不存在的时候抛出Exception
4. delMax(): 删除最大节点是Max-heap的特色。总复杂度 O(logn)
  1. 我们先交换最大节点和最后一个位置的节点，用N-- 将元素数N减少1，并且将最大节点所在位置置为空 - elements[N + 1] = null。这样可以避免loitering，避免垃圾回收机制收不到这个数组。
  2. 这时我们处在elements[1]位置上的元素有可能不满足Max heap order，我们执行 sink() 方法来进行处理。
5. sink(): 向下维护heap order。这时我们知道这个元素有可能和其两个子节点间都不满足Max heap order。我们在判断的时候要同时比较父节点和两个子节点间的大小。
  1. 假设当前父节点位置为k，那么两个可能的子节点位置为 2 * k 和 2 * k + 1。我们要先判断左子节点是否存在，也就是 2 * k 是否 <= N
  2. 在左子节点存在的条件下，我们设置 j = 2 * k，接下来我们判断右子节点是否存在，即 j是否 < N，假如右子节点存在，我们比较左右子节点的大小，并且尝试更新j 为较大子节点的index值
  3. 接下来我们判断是否较大的子节点大于父节点的值，假如为否，elements[j] < elements[k]，那么我们直接break
  4. 否则，我们交换 k 和 j - swap(k, j)，并且更新k = j，继续下一个level的sink
6. isEmpty(): pq是否为空，这是我们直接判断是否 N == 0
7. swap(): 交换两个节点
8. shuffle(): 这里使用了knuth shuffle。就是先用seed建立一个Random，然后遍历数组的时候生成伪随机数，与当前index进行交换。 O(n)
9. heapify(): 这里是指最大heapify。我们只需要从 k = N / 2开始，在k >= 1的条件下对 k 进行sink()，然后k--就可以了。
10. heapSort()：堆排序，这里我们先对数组进行heapify()，然后在k > 1的条件下每次把最大元素交换到数组尾部，再对位置1的元素进行sink就可以了。 in-place O(nlogn)。

public class MaxPQ {
    public Integer[] elements;
    public int N;
    
    public MaxPQ(int size) {
        elements = new Integer[size + 1];
        N = 0;            // index starts with 1        
    }
    
    public void insert(Integer x) {
        elements[++N] = x;
        swim(N);
    }
    
    private void swim(int k) {
        while (k > 1 && elements[k] > elements[k / 2]) {
            swap(k, k / 2);
            k /= 2;
        }
    }
    
    public Integer delMax() {
        Integer max = elements[1];
        swap(1, N--);
        elements[N + 1] = null;
        sink(1);
        return max;
    }
    
    private void sink(int k) {
        while (2 * k <= N) {
            int j = 2 * k;
            if (j < N && elements[j] < elements[j + 1]) {  
                j++;
            }
            if (elements[j] < elements[k]) {
                break;
            }
            swap(k, j);
            k = j;
        }
    }
    
    public Integer peek() {
        return elements[1];
    }
    
    public boolean isEmpty() {
        return N == 0;
    }
    
    private void swap(int i, int j) {
        Integer tmp = elements[i];
        elements[i] = elements[j];
        elements[j] = tmp;
    }
    
    public void shuffle() {            // for testing
        java.util.Random rand = new java.util.Random(System.currentTimeMillis());
        for (int i = 1; i <= N; i++) {
            int r = 1 + rand.nextInt(i);
            swap(i, r);
        }        
    }
    
    public void heapify() {            // for testing
        for (int k = N / 2; k >= 1; k--) {
            sink(k);
        }
    }
    
    public void heapSort() {
        heapify();
        int n = N;
        while (n > 1) {
            swap(1, n--);
            sink(1);
        }
    }
}

上面是用Binary heap设计一个 Max-oriented Priority Queue，数组是1-based。假如遇到面试官问怎么heapify怎么办？下面我们就对上面代码进行少许改动，变为0-based，可以直接对数组进行max - heapify。

heapify()方法: 可以看出我们的heapify方法基本没有变化，除了把N / 2变成了数组的长度 nums.length / 2
sink()方法 : 这里我们要注意一下边界条件。先设置len = nums.length，这里len就相当于之前的N，然后再进行比较的时候，我们要把每次的 j 都减1，从1-based改变为 0-based，其他代码都不需要改变

    public static void heapify(int[] nums) {
        if (nums == null) {
            return;
        }
        for (int k = nums.length / 2; k >= 1; k--) {
            sink(nums, k);
        }
    }
    
    private static void sink(int[] nums, int k) {
        int len = nums.length;
        while (2 * k <= len) {
            int j = 2 * k;
            if (j < len && nums[j - 1] < nums[j]) {
                j++;
            }
            if (nums[k - 1] > nums[j - 1]) {
                break;
            }
            swap(nums, k - 1, j - 1);
            k = j;
        }
    }
    
    private static void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }

Test Client:

public static void main(String[] args) {
        
        int len = 10;
        int[] nums = new int[len];
        for (int i = 0; i < len; i++) {
            nums[i] = i + 1; 
        }
        
        shuffle(nums);
        
        for (int i : nums) {
            System.out.print(i + " ");
        }
        
        heapify(nums);
        System.out.println();
        
        for (int i : nums) {
            System.out.print(i + " ");
        }
    }