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)的复杂度。