[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].

 

Clarification

What is heap? 

• Heap is a data structure, which usually have three methods: push, pop and top. where "push" add a new element to 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.

Example

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

Challenge 

O(n) time complexity

 

This problem is about implementing a ascending priority queue ADT using min binary heap.

It should support O(log n) insertion, O(log n) delete min, O(1) get min. 

Min Heap is a tree with the following two special properties.

1. The key of a node must be <= the keys of its children nodes

2. It must form a complete binary tree. 

 

Heapify an array, O(n)

Leaf nodes always satisfy the min heap property so we only need to heapify the non-leaf nodes;

For a complete binary tree, if there are an odd number of nodes of 2 * n + 1, then there are 

n + 1 leaf nodes and n non-leaf nodes; If there are an even number of nodes of 2 * n, then there 

are n leaf nodes and n non-leaf nodes. So the biggest index of non-leaf nodes is array.length / 2 - 1 = n - 1. 

Starting from the last non-leaf node, all the way back to root, we percolate down each of these nodes.

 

Insert, O(log n)

1. Increase the heap size by 1

2. Add the new element at the end of the heap

3. Heapify this element from bottom to top(Percolate up)

    if the new element's index is k, its parent's index is (k - 1) / 2. 

 

Delete Min, O(log n)

1. Save the root element's value 

2. Copy the last element's value into root and delete the last element

3. Percolate Down the new root element.

 

Delete Arbitrary , O(log n) if we don't need to find the arbitrary element first; O(n) if we need to find it before deletion.

If we delete an arbitrary element that is in the middle of the heap(neither root nor leaf nodes), this element has both 

parent node and children nodes, so we still swap its value with the last element then delete the last element, but instead of just precolate down the last element in its new position, we need to heapify the whole heap, iterating all the non-leaf nodes.

1. Swap value with the last element 

2. Delete the last element

3. Percolate Down on all non-leaf nodes

 

The above arbitrary deletion algorithm takes O(n) time even if the location of the to-be deleted element is given. In fact, there is no need to percolate down on all non-leaf nodes. 

The following algorithm takes O(logn) time.

1. Swap the last node's value with the deletion node's value, then remove this last node. This step maintains the "complete binary tree" invariant.

2. Fix the invariant where for each node, its key must be <= both of its children nodes' keys.

　　a. If there is no parent node for the replacement node or key of replacement node >= its parent node's key:  percolate down this replacement node;

　　b. else we have key of replacement node < its parent node's key: percolate up this replacement node. 

 

public class Solution {
    //heapify an array
    public void heapify(ArrayList<Integer> A) {
        if(A == null || A.size() <= 1)
        {
            return;
        }
        for(int i = A.size() / 2 - 1; i >= 0; i--)
        {
            percolateDown(A, i);
        }
    }
    private void percolateDown(ArrayList<Integer> A, int idx)
    {
        int minIdx = idx;
        int leftChildIdx = 2 * idx + 1;
        int rightChildIdx = 2 * idx + 2;
        
        if(leftChildIdx < A.size() && A.get(leftChildIdx) < A.get(minIdx))
        {
            minIdx = leftChildIdx;
        }
        if(rightChildIdx < A.size() && A.get(rightChildIdx) < A.get(minIdx))
        {
            minIdx = rightChildIdx;
        }
        
        if(minIdx != idx)
        {
            int temp = A.get(idx);
            A.set(idx, A.get(minIdx));
            A.set(minIdx, temp);
            percolateDown(A, minIdx);
        }
    }
    //insert
    public void insert(ArrayList<Integer> A, int val)
    {
        A.add(val);
        //precolate up the new added element
        int idx = A.size() - 1;
        while(idx > 0 && val < A.get((idx - 1) / 2)){
            A.set(idx, A.get(idx - 1) / 2);
            idx = (idx - 1) / 2;
        }
        A.set(idx, val);
    }
    //delete min
    public int deleteMin(ArrayList<Integer> A)
    {
        //swap the root element with the last element in A
        int min = A.get(0);
        A.set(0, A.get(A.size() - 1));
        A.remove(A.size() - 1);
        //precolate down the new root
        percolateDown(A, 0);
        return min;
    }
    
    //delete arbitrary, assuming we know the idx of to be deleted element
    public int delete(ArrayList<Integer> A, int deleteIdx)
    {
        int del = ArrayList.get(deleteIdx);
        //swap the to be deleted element with the last element in A
        //then remove the last element
        A.set(deleteIdx, A.get(A.size() - 1));
        A.remove(A.size() - 1);
        
        //need to heapify all the non-leaf nodes as the deleted element 
        //has both parent and children nodes
        for(int i = A.size() / 2 - 1; i >= 0; i++)
        {
            percolateDown(A, i);
        }
        return del;
    }
}

 

Optimized O(logn) aribtrary deletion

private void percolateUp(ArrayList<Integer> A, int idx) {
    if(idx < 0) {
        return;
    }
    int val = A.get(idx);
    while(idx > 0 && val < A.get((idx - 1) / 2)) {
        A.set(idx, A.get((idx - 1) / 2));
        idx = (idx - 1) / 2;
    }
    A.set(idx, val);
}
public int delete(ArrayList<Integer> A, int deleteIdx) {
    int del = ArrayList.get(deleteIdx);
    A.set(deleteIdx, A.get(A.size() - 1));
    A.remove(A.size() - 1);
    int parentIdx = (deleteIdx - 1) / 2;
    if(deleteIdx == 0 || A.get(deleteIdx) >= A.get(parentIdx)) {
        percolateDown(A, deleteIdx);
    }
    else {
        percolateUp(A, deleteIdx);
    }
    return del;
}

 

Related Problems

HeapSort