JAVA--堆算法实现

/**
 *
 */

/**
 * Date:2013-3-19
 * <p>
 * comment: 堆算法实现
 * <p>
 *
 * @author Liao, Ku-Cheng
 */
public class JAVAHeap
{
    private static int MAX_VALUE = 8;
    private Object[] values;
    private int size;
    private int initCapacity;

    public JAVAHeap()
    {
        this(MAX_VALUE);
    }

    public JAVAHeap(int initCapacity)
    {
        this.initCapacity = initCapacity;
        if (initCapacity <= 0)
        {
            initCapacity = MAX_VALUE;
        }
        values = new Object[initCapacity];
    }

    /**
     * 入堆
     *
     * @param value
     * @return
     */
    public boolean push(Object value)
    {
        if (null == value)
        {
            throw new NullPointerException();
        }
        if (size == initCapacity)
        {
            inCreaseCapacity();
        }
        values[size] = value;
        fixAfterInsert();
        size++;
        return true;
    }

    /**
     * 扩容
     */
    private void inCreaseCapacity()
    {
        initCapacity = initCapacity << 1;
        Object[] dest = new Object[initCapacity];
        System.arraycopy(values, 0, dest, 0, size);
        values = dest;
    }

    /**
     * 插入后修复数据
     */
    private void fixAfterInsert()
    {
        int index = size;
        int pIndex;
        while (index > 0)
        {
            pIndex = (index - 1) / 2;
            if (values[pIndex].hashCode() >= values[index].hashCode())
            {
                return;
            }
            else
            {
                Object tmp = values[pIndex];
                values[pIndex] = values[index];
                values[index] = tmp;
                index = pIndex;
            }
        }
    }

    /**
     * 删除数据后修复堆
     */
    private void fixAfterDelete()
    {
        int index = 0;
        int child;
        Object tmp = values[index];
        while ((child = getMaxChildIndex(index)) > 0)
        {
            if (values[index].hashCode() < values[child].hashCode())
            {
                values[index] = values[child];
                values[child] = tmp;
                index = child;
            }
            else
            {
                break;
            }
        }

    }

    /**
     * 获取最大的子节点的下标,如果不存在子节点，返回-1；
     *
     * @param index
     * @return
     */
    private int getMaxChildIndex(int index)
    {
        int right = (index + 1) * 2;
        int left = index * 2 + 1;
        if (right >= size)
        {
            right = -1;
        }
        if (left >= size)
        {
            left = -1;
        }
        // right == left,此时都为 -1
        if (right == left)
        {
            return -1;
        }
        // right大于0,因为堆未完全二叉树，这left也大于0
        if (right > 0)
        {
            return values[right].hashCode() > values[left].hashCode() ? right : left;
        }
        else
        {
            return left;
        }
    }

    /**
     * 获取堆顶数据，同时从堆中移除，如果堆为空，返回null;
     *
     * @return
     */
    public Object poll()
    {
        if (size == 0)
        {
            return null;
        }
        Object value = values[0];
        size--;
        values[0] = values[size];
        values[size] = null;
        fixAfterDelete();
        return value;
    }

    /**
     * 获取堆顶数据;如果堆为空，返回null;
     *
     * @return
     */
    public Object get()
    {
        if (size == 0)
        {
            return null;
        }
        return values[0];
    }

    /**
     * 打印数据
     */
    public void display()
    {
        for (int i = 0; i < size; i++)
        {
            System.out.print(values[i] + "  ");
        }
        System.out.println();
    }

    public static void main(String[] args)
    {
        JAVAHeap heap = new JAVAHeap(2);
        for (int i = 0; i < 20; i++)
        {
            heap.push(i);
        }
        heap.display();
        heap.poll();
        heap.display();

    }
}