LintCode-Heapify

Given an integer array, heapify it into a min-heap array.

For a heap array A, A[0] is the root of heap, and for each A[i], A[i * 2 + 1] is the left child of A[i] and A[i * 2 + 2] is the right child of A[i].

Example

Given [3,2,1,4,5], return [1,2,3,4,5] or any legal heap array.

Challenge

O(n) time complexity

Clarification

What is heap?

• Heap is a data structure, which usually have three methods: push, pop and top. where "push" add a new element the heap, "pop" delete the minimum/maximum element in the heap, "top" return the minimum/maximum element.

 

What is heapify?

• Convert an unordered integer array into a heap array. If it is min-heap, for each element A[i], we will get A[i * 2 + 1] >= A[i] and A[i * 2 + 2] >= A[i].

 

What if there is a lot of solutions?

• Return any of them.

Solution:

I implemented a Heap class that can specify min heap or max heap with insert, delete root and build heap functions.

class Heap{
    private int[] nodes;
    private int size;
    private boolean isMaxHeap;
    
    public Heap(int capa, boolean isMax){
        nodes = new int[capa];
        size = 0;
        isMaxHeap = isMax;
    }

    //Build heap from given array.
    public Heap(int[] A, boolean isMax){
        nodes = new int[A.length];
        size = A.length;
        isMaxHeap = isMax;
        for (int i=0;i<A.length;i++) nodes[i] = A[i];
        int start = A.length/2;
        for (int i=start;i>=0;i--)
            shiftDown(i);
    }

    //Assume A and nodes have the same length.
    public void getNodesValue(int[] A){
        for (int i=0;i<nodes.length;i++) A[i] = nodes[i];
    }    
    
    public boolean isEmpty(){
        if (size==0) return true;
        else return false;
    }

    public int getHeapRootValue(){
        //should throw exception when size==0;
        return nodes[0];
    }

    private void swap(int x, int y){
        int temp = nodes[x];
        nodes[x] = nodes[y];
        nodes[y] = temp;
    }

    public boolean insert(int val){
        if (size==nodes.length) return false;
        size++;
        nodes[size-1]=val;
        //check its father iteratively.
        int cur = size-1;
        int father = (cur-1)/2;
        while (father>=0 && ((isMaxHeap && nodes[cur]>nodes[father]) || (!isMaxHeap && nodes[cur]<nodes[father]))){
            swap(cur,father);
            cur = father;
            father = (cur-1)/2;
        }
        return true;
    }

    private void shiftDown(int ind){
        int left = (ind+1)*2-1;
        int right = (ind+1)*2;
        while (left<size || right<size){
            if (isMaxHeap){
                int leftVal = (left<size) ? nodes[left] : Integer.MIN_VALUE;
                int rightVal = (right<size) ? nodes[right] : Integer.MIN_VALUE;
                int next = (leftVal>=rightVal) ? left : right;
                if (nodes[ind]>nodes[next]) break;
                else {
                    swap(ind,next);
                    ind = next;
                    left = (ind+1)*2-1;
                    right = (ind+1)*2;
                }
            } else {
                int leftVal = (left<size) ? nodes[left] : Integer.MAX_VALUE;
                int rightVal = (right<size) ? nodes[right] : Integer.MAX_VALUE;
                int next = (leftVal<=rightVal) ? left : right;
                if (nodes[ind]<nodes[next]) break;
                else {
                    swap(ind,next);
                    ind = next;
                    left = (ind+1)*2-1;
                    right = (ind+1)*2;
                }
            }
        }
    }    

    public int popHeapRoot(){
        //should throw exception, when heap is empty.

        int rootVal = nodes[0];
        swap(0,size-1);
        size--;
        if (size>0) shiftDown(0);
        return rootVal;
    }
}
        
            
    

public class Solution {
    /**
     * @param A: Given an integer array
     * @return: void
     */
    public void heapify(int[] A) {
        if (A.length==0) return;
    
        Heap minHeap = new Heap(A,false);
        minHeap.getNodesValue(A);
    }
}