Data Structure & Java: 堆、堆排序与PriorityQueue

堆的实质：

堆其实是一棵特殊的完全二叉树。每一个结点的值都大于或者等于左右孩子结点的值（大顶堆），或者每一个结点的值都小于等于左右孩子结点的值（小顶堆）。

对于完全二叉树，因为除了最后一层，其它的层都是满的。所以，一般对于平衡二叉树可以利用顺序存储结构（数组）。所以，对应完全二叉树的顺序存储结构：

数组的i（index = i）结点的父结点下标就为(i – 1) / 2。它的左右子结点下标分别为2 * i + 1和2 * i + 2。如第0个结点左右子结点下标分别为1和2【1】。

下面我们以小顶堆作为例子，讲述堆排序的原理：由于我们总能保证堆顶是最小值，所以，每次我们可以取堆顶元素出来加入结果数组，然后让堆自己调整，直到堆为空。

上述每次从堆顶取出元素的操作称为堆的删除操作。在删除堆顶元素前，需要考虑堆的插入：

首先把新元素放在数组的尾部。然后，进行siftUp(int k, Object e). 把新元素不断和父节点、父节点的父节点比较，直到其比新的父节点要大就可以停止了。否则，下移当前父节点，keep going. 

删除堆元素则相反：首先把数组的尾部放在数组头，然后进行siftDown(int k, Object e). 把新元素不断和两个子节点中较小的子节点交换（注意，不同于父节点，子节点有两个，必须选最小的），一直到其比子节点大。这里有个特殊情况，假如k<(int)(size>>>1)，也就是lowfloor(数组的长度/2)，这是拥有子节点的父节点的index，是需要考虑下移的。但如果大于这个值，则是叶子节点，不需要下移。

这是因为完全二叉树的性质决定的，完全二叉树中，当前节点的父节点的Index是lowerfloor(n/2)，n是当前节点的index。

所以，我们可以用这个方法实现一个Priority Queue:

import java.util.Arrays;

public class PriorityQueue{
	private static final int DEFALUT_SIZE = 10;
	private int[] elem;
	private int size;
	
	public PriorityQueue(int size){
		if(size <= 0){
			elem = new int[DEFALUT_SIZE];
		}else{
			elem = new int[size];
		}
		size = 0;
	}
	
	public void add(int item){
		int t = size;
		if(t >= elem.length){
			this.grow(t+1);
		}
		
		size = t+1;
		if(t == 0){
			elem[0] = item;//直接赋值
		}else{
			siftUp(t, item);
		}
	}
	
	public int removeTop() throws IndexOutOfBoundsException{
		if(size == 0){
			throw new IndexOutOfBoundsException();
		}
		
		int return_val = elem[0];
		int tmp = elem[size-1];
	    elem[size-1] = 0;
	    
	    size = size - 1;
	    if(size > 0){
	    	siftDown(0, tmp);
	    }
	    return return_val;
	}
	private void grow(int min_size){
		//一般而言，java的算法是大于64的时候采用*3再除以2，也就是乘以1.5
		//当小于64时，乘以2
		
		int old_size = elem.length;
		int new_size = old_size > 64? old_size*3/2 : old_size*2;
		
		if(new_size < old_size){//整形数溢出了
			new_size = Integer.MAX_VALUE;//这样获取整形数的最大值
		}
		
		if(new_size < min_size){
			new_size = min_size;
		}
		elem = Arrays.copyOf(elem, new_size);
	}
	
	private void siftUp(int k, int item){
		while(k > 0){
			int parent = (k-1) >>> 1;//注意是k-1
			if(elem[parent] < item){
				break;
			}
			
			/*否则，下沉父节点*/
			elem[k] = elem[parent];
			k = parent;
		}
		elem[k] = item;
	}
	
	private void siftDown(int k, int item){
		int half = size >>> 1;
                int child = 0;
		while(k < half){
			child = 2*k+1;
			if(elem[child] > elem[child+1]){
				//取子节点最小值
				child = child+1;
			}
			
			if(elem[k] < elem[child]){
				break;
			}
			
			elem[k] = elem[child];
			k = child;
		}
		elem[k] = item;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}

复杂度分析：

综上所述，插入的复杂度是：O(log(n))，n是PriorityQueue，或者说是堆里面的元素个数，也就是完全二叉树的层数。而removeTop的话，则是constant取出，但siftDown会是O(log(n)). 所以，N个数，每个数调用一次removeTop，复杂度就是O(nlog(n)). 

但如果是定点remove的话，参考：http://blog.csdn.net/morewindows/article/details/6709644的内容可知，有可能是上滤和下滤。上滤之后有可能会下滤，所以是O(n)的复杂度。