堆排序java简单实现

排序过程：

 1、第一次自下而上遍历所有的叶节点，在叶节点、左/右子节点中选择数值最大的与叶节点交换，即初始化为大堆顶；
 2、交换根节点和最后一个节点，取出最后一个节点的值，堆长度-1；
 3、自上而下遍历所有的叶节点，重新调整为大堆顶；
 4、重复2,3，直到堆长度=1

代码：

public class HeapSort {
	
	private static Integer[] arrs;
	private static Integer arrsLength = 100;
	private static Integer maxNum = 1000;
	
	/**初始化待排序的数组*/
	static {
		arrs = new Integer[arrsLength];
		for(int i=0;i<arrsLength;i++) {
			arrs[i] = Math.random()>0.5?(int) Math.round(Math.random()*maxNum):0-(int) Math.round(Math.random()*maxNum);
			System.out.print(arrs[i]+" ");
		}
	}

	public static void main(String[] args) {
		for(int len = arrsLength;len > 1;len--) {
			if (len == arrsLength) initMaxHeap();
			else adjustHeap(len);
			swap(0, len-1);
			System.out.println(arrs[len-1]);
		}
    }
	
	/**
	 * 初始化大堆顶：自下而上开始调整
	 */
	private static void initMaxHeap() {
		for(int i=arrsLength-1;i>=0;i--) {
			//如果有交换，则有可能影响当前节点下的所有子节点，所以又需要从当前节点开始往下重新调整
			if(changeToResonable(i,arrsLength));
        		for(int j=2*i+1;j<=arrsLength-1;j++) if(changeToResonable(j,arrsLength)) continue;
		}
	}
	
	/**
	 * 自上而下调整大堆顶
	 * @param len 待调整的长度
	 */
	private static void adjustHeap(Integer len) {
		//自上而下循环所有叶节点（包括根节点），将当前树调整为大堆顶，此时是在初始大堆顶基础上进行交换，不需要考虑交换后对父节点的影响
		for(int i=0;i<=len-1;i++) changeToResonable(i,len);
	}
	
	/**
	 * 叶节点、左、右子节点中选择数值最大的作为叶节点
	 * @param leafIdx
	 * @param leftIdx
	 * @param rightIdx
	 * @return 是否有交换
	 */
	private static boolean changeToResonable(Integer leafIdx, Integer len) {
		int leftIdx = 2*leafIdx+1;
		int rightIdx = 2*leafIdx+2;
		boolean flag = false;
		
		if (leftIdx > len-1) return flag;
		if (arrs[leafIdx] < arrs[leftIdx]) {
			swap(leafIdx, leftIdx);
			flag = true;
		}
			
		if (rightIdx > len-1) return flag;
		if (arrs[leafIdx] < arrs[rightIdx]) {
			swap(leafIdx, rightIdx);
			flag = true;
		}
		return flag;
	}
	
	private static void swap(Integer idx1, Integer idx2) {
		Integer temp;
		temp = arrs[idx1];
		arrs[idx1] = arrs[idx2];
		arrs[idx2] = temp;
	}
}

        这里展示的代码不算太好，主要是便于理解。其实还有很多可以优化的地方，比如初始化大堆顶和调整大堆顶的地方，没有必要遍历所有节点