堆排序

堆的概念：

1. 它是一棵完全二叉树。
2. 每个结点大于或等于它的任意一个孩子。（最大堆）

堆排序：

堆可以存储在一个ArrayList或数组中，树根在位置0处，它的两个孩子在位置1和2处。对于位置 i 处的结点它的左孩子在位置2i + 1 处，它的右孩子在2i+ 2 处，而它的父亲在位置（i-1）/2 处。

• 添加一个新结点

Let the last node be the current node;

while(the current node is greater than its parent)

{

Swap the current node with its parent;

Now the current node is one level up;

}

• 删除根结点

Move the last node to repalce the root;

Let the root be the current node;

public class HeapSort {
    public static <E extends Comparable>void HeapSort(E[] list)
    {
        Heap<E> heap  = new Heap<E>();
        for(int i = 0; i< list.length;i++)
            heap.add(list[i]);
        for(int i = list.length - 1; i >= 0;i--)
            list[i] = heap.remove();
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Integer[] list = {2, 3, 2, 5, 6};
        HeapSort(list);
        for(int i = 0; i< list.length; i++)
            System.out.print(list[i]+"");
    }

}
class Heap<E extends Comparable>
{
    private java.util.ArrayList<E> list = new java.util.ArrayList<E>();
    public Heap()
    {
        
    }
    public Heap(E[] objects)
    {
        for(int i = 0; i < objects.length; i++)
            add(objects[i]);
    }
    public void add(E newobject)//向堆中加入元素
    {
        list.add(newobject);//将 newobject 加入ArrayList中
        int currentIndex = list.size() - 1;
        while(currentIndex > 0)
        {
            int parentIndex = (currentIndex - 1)/2;
            if(list.get(currentIndex).compareTo(list.get(parentIndex)) > 0)
            {
                E temp = list.get(currentIndex);
                list.set(currentIndex, list.get(parentIndex));
                list.set(parentIndex, temp);
            }
            else 
                break;
            currentIndex = parentIndex;
        }
    }
    public E remove()//删除堆的root
    {
        if(list.size() == 0) return null;
        E removeObject = list.get(0);
        list.set(0, list.get(list.size() - 1));//将最后一个节点置为root
        list.remove(list.size() - 1);//将ArrayList的最后一个元素删除
        
        int currentIndex = 0;
        while(currentIndex < list.size())
        {
            int leftChildIndex = 2 * currentIndex + 1;
            int rightChildIndex =  2 * currentIndex + 2;
            if(leftChildIndex >= list.size())
                break;
            int maxIndex = leftChildIndex;
            if(rightChildIndex < list.size())
            {
                if(list.get(maxIndex).compareTo(list.get(rightChildIndex)) < 0)
                    maxIndex = rightChildIndex;
            }
            if(list.get(currentIndex).compareTo(list.get(maxIndex)) < 0)
            {
                E temp = list.get(maxIndex);//节点的交换
                list.set(maxIndex,list.get(currentIndex));
                list.set(currentIndex, temp);
                currentIndex = maxIndex;
            }
            else
                break;
        }
        return removeObject;
    }
    public int getSize()
    {
        return list.size();
    }
}