Heap 排序

Heap排序想必大家都知道。

Heap的主要是通过完全二叉树的形式来构建。这样的构建是平横二叉树（树的高度为lg（N））。

主要特点是：

1. 根节点用来存最大或者最小的树值（利用此特征，可以来做优先队列）。

2. 节点i的值都大于或者小于其子节点（注意啦，heap有，max heap 和min heap之分）。

heap排序的大概流程，也就是

1. 构建heap。

2. 删除根节点，最大或者最小值

3. 重新构建heap， 跳到2，直到heap的size为零。

时间复杂度为O(nlgn)

一下是heap的java版本。

public class MyHeap{
	public static void main(String[] args){
		int[] array = {4, 1, 3, 2, 5};
		MyHeap heap = new MyHeap(array);
		heap.print();
		heap.buildHeap();
		//heap.sort();
		heap.print();
	}
	
	private int[] array;
	public MyHeap(int[] array){
		this.array = array;
	}
	
	public int size(){
		return array.length;
	}
	
	private void maxHeap(int i){
		int l = left(i);
		int r = right(i);
		int mx = i;
		if(l < size() && array[l] > array[i])
			mx = l;
		if(r < size() && array[r] > array[mx])
			mx = r;
		if(mx != i){
			swap(mx, i);
			maxHeap(mx);
		}		
	}
	
	public void sort(){
		buildHeap();
		for(int i = size() - 1; i >= 0; i--){
			swap(i, 0);
			maxHeap(0, i);
		}
	}
	/**
	 * index and size
	 * */
	private void maxHeap(int i, int len){
		int l = left(i);
		int r = right(i);
		int mx = i;
		if(l < len && array[l] > array[i])
			mx = l;
		if(r < len && array[r] > array[mx])
			mx = r;
		if(mx != i){
			swap(mx, i);
			maxHeap(mx, len);
		}		
		
	}
	private void swap(int i, int j){
		int tmp = array[i];
		array[i] = array[j];
		array[j] = tmp;
	}
	
	public void buildHeap(){
		int half = size()/2;
		for(int i = half; i >=0; i--){
			maxHeap(i);
		}
	}
	
	public int left(int idx){
		return  idx * 2 + 1;
	}
	public int right(int idx){
		return 2 * (idx + 1);
	}
	
	public int parent(int idx){
		return (idx-1)/2;
	}
	public void print(){
		System.out.print("[");
		for(int i : array){
			System.out.print(i + " ");
		}
		System.out.println("]");
	}
}