Heap和Heapify

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

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

1. 这里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<>()
2. 一开始的构造方法里，我们为简便使用了一个定长的数组。正常来说应该使用一个resizing array，以及一个load factor。
   1. 当load factor，也就是元素数 N / 数组长度 len = 0.75的时候，我们把数组扩容一倍，然后把之前的元素拷贝进去
   2. 当load factor < 0.25的时候，我们把数组减半，也要拷贝之前的元素。 
3. 主要的一些方法有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。

1. heapify()方法: 可以看出我们的heapify方法基本没有变化，除了把N / 2变成了数组的长度 nums.length / 2
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 + " ");
        }
    }
    

Reference:

http://algs4.cs.princeton.edu/24pq/