堆排序

import java.util.Arrays;

public class HeapSort {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] data = { 1, 4, 5, 12, 7, 8, 9, 10 };
		heapSort(data);
		System.out.println(Arrays.toString(data));
	}

	private static void heapSort(int[] data) {
		int arrayLength = data.length;
		for (int i = 0; i <= arrayLength - 1; i++) {
			buildMaxHeap(data, arrayLength - i - 1);
			swap(0, arrayLength - 1 - i, data);
			System.out.println(Arrays.toString(data));
		}
	}

	private static void swap(int i, int j, int data[]) {
		int tmp;
		tmp = data[i];
		data[i] = data[j];
		data[j] = tmp;
	}

	  private static void buildMaxHeap1(int[] data, int lastIndex) {
	        // TODO Auto-generated method stub
	        //从lastIndex处节点（最后一个节点）的父节点开始
	        for(int i=(lastIndex-1)/2;i>=0;i--){
	            //k保存正在判断的节点
	            int k=i;
	            //如果当前k节点的子节点存在
	            while(k*2+1<=lastIndex){
	                //k节点的左子节点的索引
	                int biggerIndex=2*k+1;
	                //如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在
	                if(biggerIndex<lastIndex){
	                    //若果右子节点的值较大
	                    if(data[biggerIndex]<data[biggerIndex+1]){
	                        //biggerIndex总是记录较大子节点的索引
	                        biggerIndex++;
	                    }
	                }
	                //如果k节点的值小于其较大的子节点的值
	                if(data[k]<data[biggerIndex]){
	                    //交换他们
	                    swap(k,biggerIndex,data);
	                    //将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值
	                    k=biggerIndex;
	                }else{
	                    break;
	                }
	            }
	        }
	    }
	
	
	
	private static void buildMaxHeap(int[] data, int lastIndex) {
		int k ;
		// 从最后的节点的父节点开始
		for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
			k = i;
			while (2 * k + 1 <= lastIndex) {
				int biggerIndex = 2 * k + 1;
				if (biggerIndex < lastIndex) {
					if (data[biggerIndex] < data[biggerIndex+1]) {
						biggerIndex++;
					}
				}
				if (data[k] < data[biggerIndex]) {
					swap(k, biggerIndex, data);
					k = biggerIndex;
				} else {
					break;
				}
			}
			
		}
	}
}