LintCode：堆化

描述

给出一个整数数组，堆化操作就是把它变成一个最小堆数组。

对于堆数组A，A[0]是堆的根，并对于每个A[i]，A [i * 2 + 1]是A[i]的左儿子并且A[i * 2 + 2]是A[i]的右儿子。

说明

什么是堆？

• 堆是一种数据结构，它通常有三种方法：push， pop 和 top。其中，“push”添加新的元素进入堆，“pop”删除堆中最小/最大元素，“top”返回堆中最小/最大元素。

什么是堆化？

• 把一个无序整数数组变成一个堆数组。如果是最小堆，每个元素A[i]，我们将得到A[i * 2 + 1] >= A[i]和A[i * 2 + 2] >= A[i]

如果有很多种堆化的结果？

• 返回其中任何一个。

样例

给出 [3,2,1,4,5]，返回[1,2,3,4,5] 或者任何一个合法的堆数组

 

思路：这道题就是一个堆排序吧，每次从第 n/2 个节点出开始调整，然后将shu'数组中所有的元素都调整一遍。

Java代码：

1. 从 n/2 处确保以下的节点都是有序的，然后一直迭代到根节点。每次调整父节点时可能导致下面的节点又不满足堆了，所以每次都要一直向下迭代一遍。

private void siftdown(int[] A, int k) {
        while (k * 2 + 1 < A.length) {
            int son = k * 2 + 1;
            if (k * 2 + 2 < A.length && A[son] > A[k * 2 + 2])
                son = k * 2 + 2;
            if (A[son] >= A[k])
                break;
            
            int temp = A[son];
            A[son] = A[k];
            A[k] = temp;
            k = son;
        }
    }
    
    public void heapify(int[] A) {
        for (int i = (A.length - 1) / 2; i >= 0; i--) {
            siftdown(A, i);
        }
    }

2. 跟上面的过程反过来了，每次确保前面的节点有序。

    public void heapify(int[] A) {
        // write your code here
        if(A.length==0){
            return;
        }
        int len = A.length;
        for (int i = 0; i<len; i++) {
            shifup(A, i);
        }
    }
    public void shifup(int[] A, int n){
        while (n != 0){
            int father = (n-1)/2;
            if(A[n] > A[father]){
                break;
            }
            int temp = A[n];
            A[n] = A[father];
            A[father] = temp;
            n = father;
        }
    }