数据结构之堆（java实现，有排序功能）

/*
 * 文 件 名:  HeapNode.java
 * 修改时间:  2012-12-24
 */
package heap;

/**
 * 堆节点
 * @version  [版本号, 2012-12-24]
 */
public class HeapNode
{
    /**
     * 用于排序的关键字
     */
    int key;
    /**
     * 节点的数据
     */
    double dData;
    
    /**
     * <默认构造函数>
     */
    public HeapNode(int key, double dData)
    {
        this.key = key;
        this.dData = dData;
    }
    
    /** {@inheritDoc} */
    
    @Override
    public String toString()
    {
        return "HeapNode [dData=" + dData + ", key=" + key + "]";
    }
    
}

/*
 * 文 件 名:  Heap.java
 * 修改时间:  2012-12-24
 */
package heap;

/**
 * 数据结构之堆
 * @version  [版本号, 2012-12-24]
 */
public class Heap
{
    /**
     * 
     * 堆类型枚举
     * @version  [版本号, 2012-12-24]
     */
    enum HeapType
    {
        MAX, MIN
    }
    
    /**
     * 堆节点数组
     */
    private HeapNode[] data;
    /**
     * 堆得类型
     */
    private HeapType heapType;
    /**
     * 元素个数，如果大于数组长度，需要扩容
     */
    private int elementN;
    
    /**
     * <默认构造函数>
     */
    public Heap(HeapType heapType)
    {
        this(heapType, 20);
    }
    
    /**
     * <默认构造函数>
     */
    public Heap(HeapType heapType, int capacity)
    {
        this.heapType = heapType;
        data = new HeapNode[capacity];
        elementN = 0;
    }
    
    /**
     * 判断堆是否为空
     * @return
     * @see [类、类#方法、类#成员]
     */
    public boolean isEmpty()
    {
        return elementN == 0;
    }
    
    /**
     * 向堆中添加元素
     * @see [类、类#方法、类#成员]
     */
    public void addElement(int key, double dData)
    {
        HeapNode heapNode = new HeapNode(key, dData);
        //如果数组容量已满，则扩大一倍
        if (elementN >= data.length)
        {
            HeapNode[] newArray = new HeapNode[data.length * 2];
            System.arraycopy(data, 0, newArray, 0, data.length);
            data = newArray;
        }
        int currentIndex = elementN;
        data[elementN++] = heapNode;
        //下面从currentIndex索引开始回朔看看是否符合堆得特性
        while (currentIndex > 0)
        {
            //这里需要判断堆得类型，是最大堆还是最小堆
            if (heapType == HeapType.MAX && data[currentIndex].key <= data[(currentIndex - 1) / 2].key)
            {
                break;
            }
            else if (heapType == HeapType.MIN && data[currentIndex].key >= data[(currentIndex - 1) / 2].key)
            {
                break;
            }
            else
            {
                swapNode(currentIndex, (currentIndex - 1) / 2);
                currentIndex = (currentIndex - 1) / 2;
            }
        }
    }
    
    /**
     * 删除堆顶元素
     * @return
     * @see [类、类#方法、类#成员]
     */
    public HeapNode removeRoot()
    {
        HeapNode temp = null;
        if (!isEmpty())
        {
            temp = data[0];
            if (elementN > 1)
            {
                data[0] = data[elementN - 1];
                //下面向下遍历各节点保持堆特性,从0开始遍历到elementN-2
                reHeap(elementN - 2);
            }
            else
            {
                data[0] = null;
            }
            elementN--;
        }
        return temp;
    }
    
    /**
     * 将0到lastIndex的堆重新排列以符合堆得特性
     * @param lastIndex
     * @see [类、类#方法、类#成员]
     */
    private void reHeap(int lastIndex)
    {
        int currentIndex = 0;
        while (currentIndex * 2 + 1 <= lastIndex)
        {
            //如果有右节点
            if (currentIndex * 2 + 2 <= lastIndex)
            {
                //如果右节点的值大于左节点的
                if (data[currentIndex * 2 + 2].key >= data[currentIndex * 2 + 1].key)
                {
                    if (heapType == HeapType.MAX && data[currentIndex].key <= data[currentIndex * 2 + 2].key)
                    {
                        swapNode(currentIndex, currentIndex * 2 + 2);
                        currentIndex = currentIndex * 2 + 2;
                    }
                    else if (heapType == HeapType.MIN && data[currentIndex].key >= data[currentIndex * 2 + 1].key)
                    {
                        swapNode(currentIndex, currentIndex * 2 + 1);
                        currentIndex = currentIndex * 2 + 1;
                    }
                    else
                    {
                        break;
                    }
                }
                else
                {
                    if (heapType == HeapType.MAX && data[currentIndex].key <= data[currentIndex * 2 + 1].key)
                    {
                        swapNode(currentIndex, currentIndex * 2 + 1);
                        currentIndex = currentIndex * 2 + 1;
                    }
                    else if (heapType == HeapType.MIN && data[currentIndex].key >= data[currentIndex * 2 + 2].key)
                    {
                        swapNode(currentIndex, currentIndex * 2 + 2);
                        currentIndex = currentIndex * 2 + 2;
                    }
                    else
                    {
                        break;
                    }
                }
            }
            //如果没有右节点
            else
            {
                if (heapType == HeapType.MAX && data[currentIndex].key <= data[currentIndex * 2 + 1].key)
                {
                    swapNode(currentIndex, currentIndex * 2 + 1);
                    currentIndex = currentIndex * 2 + 1;
                }
                else if (heapType == HeapType.MIN && data[currentIndex].key >= data[currentIndex * 2 + 1].key)
                {
                    swapNode(currentIndex, currentIndex * 2 + 1);
                    currentIndex = currentIndex * 2 + 1;
                }
                else
                {
                    break;
                }
            }
        }
    }
    
    /**
     * 交换两个节点
     * @see [类、类#方法、类#成员]
     */
    private void swapNode(int index1, int index2)
    {
        HeapNode node = data[index1];
        data[index1] = data[index2];
        data[index2] = node;
    }
    
    /**
     * 返回堆中得元素个数
     * @return
     * @see [类、类#方法、类#成员]
     */
    public int getSize()
    {
        return elementN;
    }
    
    /**
     * 查看根元素
     * @return
     * @see [类、类#方法、类#成员]
     */
    public HeapNode getRoot()
    {
        HeapNode root = null;
        if (!isEmpty())
        {
            root = data[0];
        }
        return root;
    }
    
    /**
     * 遍历堆
     * @see [类、类#方法、类#成员]
     */
    public void displayHeap()
    {
        if (!isEmpty())
        {
            for (int i = 0; i <= elementN - 1; i++)
            {
                System.out.println(data[i].toString());
            }
        }
    }
    
    /**
     * 将堆中的元素排序
     * @see [类、类#方法、类#成员]
     */
    public void sort()
    {
        if (elementN > 1)
        {
            for (int i = elementN; i > 1; i--)
            {
                swapNode(0, i - 1);
                reHeap(i - 2);
            }
        }
    }
}