JAVA的堆排序

这连续的三个排序都是有关于大数据处理的面试题，本人手贱，当初笔试参与的是4399的数据研发，结果通知笔试后才发现真心难，只好零时抱佛脚，多看看这方面的概念以及一些笔试题面试题，也不知道能不能过他们的面试。

以下这段代码我是直接从百度词条copy出来的，能用，至于效率如何，还未尝试：

package demo;

public class Heapsort{
	
	private static int[] sort=new int[]{1,0,10,20,3,5,6,4,9,8,12,17,34,11};
 
	public static void main(String[] args){
		buildMaxHeapify(sort);
		heapSort(sort);
		print(sort);
	}
 
	private static void buildMaxHeapify(int[] data){                  //没有子节点的才需要创建最大堆，从最后一个的父节点开始
		int startIndex=getParentIndex(data.length-1);                 //从尾端开始创建最大堆，每次都是正确的堆
		for(int i=startIndex;i>=0;i--){
			maxHeapify(data,data.length,i);
		}
	}
 
	/**
	*创建最大堆
	*
	*@paramdata
	*@paramheapSize需要创建最大堆的大小，一般在sort的时候用到，因为最多值放在末尾，末尾就不再归入最大堆了
	*@paramindex当前需要创建最大堆的位置
	*/
	private static void maxHeapify(int[] data,int heapSize,int index){                   //当前点与左右子节点比较
		
		int left=getChildLeftIndex(index);
		int right=getChildRightIndex(index);
		int largest=index;
		if(left<heapSize&&data[index]<data[left]){
			largest=left;
		}
		if(right<heapSize&&data[largest]<data[right]){
			largest=right;
		}                           //得到最大值后可能需要交换，如果交换了，其子节点可能就不是最大堆了，需要重新调整
		if(largest!=index){
			int temp=data[index];
			data[index]=data[largest];
			data[largest]=temp;
			maxHeapify(data,heapSize,largest);
		}
	}
 
	/**
	*排序，最大值放在末尾，data虽然是最大堆，在排序后就成了递增的
	*
	*@paramdata
	*/
	private static void heapSort(int[] data){                  //末尾与头交换，交换后调整最大堆
		for(int i=data.length-1;i>0;i--){
			int temp=data[0];
			data[0]=data[i];
			data[i]=temp;
			maxHeapify(data,i,0);
		}
	}
 
	/**
	*父节点位置
	*
	*@paramcurrent
	*@return
	*/
	private static int getParentIndex(int current){
		return(current-1)>>1;
	}
 
	/**
	*左子节点position注意括号，加法优先级更高
	*
	*@paramcurrent
	*@return
	*/
	private static int getChildLeftIndex(int current){
		return(current<<1)+1;
	}
 
	/**
	*右子节点position
	*
	*@paramcurrent
	*@return
	*/
	private static int getChildRightIndex(int current){
		return(current<<1)+2;
	}
 
	private static void print(int[] data){
		int pre=-2;
		for(int i=0;i<data.length;i++){
			if(pre<(int)getLog(i+1)){
				pre=(int)getLog(i+1);
				System.out.println();
			}
			System.out.print(data[i]+"|");
		}
	}
 
	/**
	*以2为底的对数
	*
	*@paramparam
	*@return
	*/
	private static double getLog(double param){
		return Math.log(param)/Math.log(2);
	}
}

其实堆排序的概念十分好理解：堆可以被看做一个完全二叉树，所以每一个节点都能够被计算出来，堆分为大根堆和小根堆，大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。反过来，小根堆的要求就是每个节点的值都大于其父节点，即A[PARENT[i]] < A[i]。在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆.顶。

有一篇博客写的很好，想贴出来，提醒自己以后去看看：

http://blog.csdn.net/kimylrong/article/details/17150475