堆排序(HeapSort)

public class HeapSort {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int[] A = {4,1,3,2,16,9,10,14,8,7};
		
		heapSort(A);
		for(int i : A){
			System.out.println(i);
		}
		
	}
	
	
	
	/**
	 * HEAP-SORT(A)
	 * BUILD-MAX-HEAP(A)
	 * for i = length[A] downto 2
	 * 	do exchange A[1]<->A[i]
	 * 		heap-size[A]<-heap-size[A]-1
	 * 		MAX-HEAPIFY(A,1)
	 * 
	 * */
	private static void heapSort(int[] A){
		buildMaxHeap(A);
		for(int i=A.length-1; i>=1; i--){
			int temp = A[0];
			A[0] = A[i];
			A[i] = temp;
			maxHeapify(A,i,1);
		}
		
	}
	
	
	/**
	 * BUILD-MAX-HEAP(A)
	 * heap-size[A] = length[A]
	 * for i = length[A]/2 downto 1
	 * 	do MAX-HEAPIFY(A,i)
	 * 
	 * */
	private static void buildMaxHeap(int[] A){
		int heapSize = A.length;
		for(int i = heapSize/2; i>0; i--){
			maxHeapify(A,heapSize, i);
		}
		
	}
	
	
	
	
	/**
	 * MAX-HEAPIFT(A,i)
	 * 
	 * 	l = left(i)
	 * 	r = right(i)
	 * 	if l<=heap-size[A] and A[l]>A[i]
	 * 		then largest = l
	 * 		else largest = i
	 * 	if r<=heap-size[A] and A[r]>A[largest]
	 * 		then largest = r
	 * 	if largest!=i
	 * 		then exchange A[i]<->A[largest]
	 * 			MAX-HEAPIFY(A,largest) 
	 * 
	 * 
	 * */
	private static int[] maxHeapify(int[] A,int heapsize, int i){
		int l = left(i)-1;
		int r = right(i)-1;
		i--;
		int largest = 0;
		if(l<heapsize && A[l]>A[i]){
			largest = l;
		}else{
			largest = i;
		}
		
		if(r<heapsize && A[r]>A[largest]){
			largest = r;
		}
		
		if(largest != i){
			int temp = A[i];
			A[i] = A[largest];
			A[largest] = temp;
			maxHeapify(A,heapsize,largest+1); 
		}
		
		return A;
	}
	
	/**
	 * 父节点
	 * PARENT(i)
	 * 	RETURN i/2
	 * 
	 * */
	private static int parent(int i){
		
		return i/2;
	}

	/**
	 * 左侧子节点
	 * LEFT(i)
	 * 	RETURN 2i
	 * 
	 * */
	private static int left(int i){
		return 2*i;
	}
	
	/**
	 * 右侧子节点
	 * RIGTH(i)
	 * 	RETURN 2i+1
	 * 
	 * */
	private static int right(int i){
		return 2*i+1;
	}
	
	
	

}