heapify的总结

原题地址http://www.lintcode.com/zh-cn/problem/heapify/#
一.目的：将一组无序数组堆化
二.思路：根据堆的特性——每个A[i]，A [i * 2 + 1]是A[i]的左儿子并且A[i * 2 + 2]是A[i]的右儿子这一特性，从A.length / 2，开始循环下滤。处理完一个节点，for循环处-1。下滤的时间复杂度为O(n)。上滤的时间爱你复杂度为O(nlogn)。
三.易错点：for循环的判断条件为 i <= 0；若无=则忽略了根节点。

采用下滤方法的堆化：

public class Solution {
    /**
     * @param A: Given an integer array
     * @return: void
     */
    public void heapify(int[] A) {
           for(int i = A.length / 2; i >= 0; i--){             
               percolateDown(A, i);
           }
       }
    public void percolateDown(int[] A, int k){
       while(k < A.length){
            int smaller = k;
            if(k * 2 + 1 < A.length && A[smaller] > A[k * 2 + 1]){
                smaller = k * 2 + 1;
            }
            if(k * 2 + 2 < A.length && A[smaller] > A[k * 2 + 2]){
               smaller = k * 2 + 2;
            }
            if(smaller == k){
               break;
            }
               int temp = A[smaller];
               A[smaller] = A[k];
               A[k] = temp;
               k = smaller;
       }
    }
}

采用上滤方法的堆化：

public class Solution {
    /**
     * @param A: Given an integer array
     * @return: void
     */
    private void siftup(int[] A, int k) {
        while (k != 0) {
            int father = (k - 1) / 2;
            if (A[k] > A[father]) {
                break;
            }
            int temp = A[k];
            A[k] = A[father];
            A[father] = temp;

            k = father;
        }
    }

    public void heapify(int[] A) {
        for (int i = 0; i < A.length; i++) {
            siftup(A, i);
        }
    }
}