1.原地排序，不穩定的，時間複雜度為O（logn） logn為堆的高度；在任何時候陣列中只有常數個元素儲存在輸入陣列之外’

呼叫遞迴方法實現的堆排序空間複雜度為O（logn），而非遞迴的才是O（1）

2.值得注意的是：

當陣列下標從1開始，即（1<=i<n+1）時，節點 i 的左孩子為 2i,右孩子為 2i+1（右孩子不一定有），i 的父親為 i/2，最後一個父親節點為 n/2

當陣列下標從0開始，即（0<=i<n）時，節點 i 的左孩子為 2i+1，右孩子為 2i+2(右孩子不一定有），i 的父親節點為 (i-1)/2，最後一個父親節點為 (n-1)/2

3.堆排序原理：最大堆節點 i 的值比它的左右字數的值都大 即：父親節點的值>孩子節點值（最小堆相反）

4.演算法步驟：heap_size 最大堆的大小，不是陣列元素個數的大小length；

（1）維持最大堆： maxHeapify(int [] a，int i):是對節點i開始維持：首先i處的值要是左右孩子和其本身三個節點值中最大的那個，如果其本身最大則節點i保持最大堆性質，不用動；否則值最大的孩子和節點i交換位置，然後對節點i的新位置(原來孩子處)開始維持最大堆性質（遞迴）。

該步驟的時間複雜度為O（logn）  n為節點數 或者O（h）h為堆高度

（2）建立最大堆：buildMaxHeap(int[] a): 自底向上用maxHeapify對每一個父親節點（最後面的父親節點是n-1/2 前面有講到）建立最大堆，即對n-1/2 到0開始呼叫maxHeapify函式。

該步驟的時間輔助度是對每個父節點呼叫維持最大堆性質函式，所以時間複雜度為O(nlogn)

（3）堆排序演算法heapSort(int[] a)：首先建立最大堆buildMaxHeap(a); 其次從尾節點開始到第二個節點（i從length-1降低到1）交換根節點和尾節點，這裡heap_size開始減小；

然後每次對根節點呼叫維持最大堆函式maxHeapify(a,0).

該演算法的時間複雜度是O(nlogn)

5.實現過程：（1）

//4.堆排序
	//維持最大堆性質：i表示待維持的節點
	public static void maxHeapify(int[] array,int heapSize,int i){
		int left=2*i+1;
		int right=2*i+2;//左右孩子位置，注意 右孩子不一定存在
		int largest=i;
		if(left<heapSize&&array[left]>array[i]){
			largest=left;
		}
		if(right<heapSize&&array[right]>array[largest]){
			largest=right;
		}
		if(largest!=i){//節點i處值不是三者中最大的，則交換i和largest兩處的節點，
			int temp=array[i];
			array[i]=array[largest];
			array[largest]=temp;
			maxHeapify(array,heapSize,largest);//交換後對孩子處(節點i的新位置)進行維持最大堆性質
		}
	}
	public static void maxHeapify2(int[] array,int heapSize,int i){//非遞迴的維持最大堆性質函式
		while(true){//迴圈代替遞迴
			int left=2*i+1;
			int right=2*i+2;
			int largest=i;
			if(left<heapSize&&array[left]>array[i]){
				largest=left;
			}
			if(right<heapSize&&array[right]>array[largest]){
				largest=right;
			}
			if(largest!=i){
				int temp=array[i];
				array[i]=array[largest];
				array[largest]=temp;
				i=largest;//非遞迴的方式
			}else{
				break;
			}
		}
	}
	//建立最大堆:自底向上對每個父節點開始呼叫維持性質函式，注意是自底向上
	public static void buildMaxHeap(int[] array){
		if(array==null||array.length<=1)return;
		int heapSize=array.length;
		int half=(array.length-1)/2;
		for(int i=half;i>=0;i--){//自底向上 注意最後一個父節點的位置是n-1/2
			maxHeapify(array,heapSize,i);
		}
	}
	//堆排序函式:先建立最大堆，然後交換尾節點和根節點，在對根節點維持最大堆性質
	public static void heapSort(int[] array){
		if(array==null||array.length<=1) return;
		buildMaxHeap(array);//建立最大堆
		for(int i=array.length-1;i>0;i--){//此處i最小值為1，此時只有根節點和I節點 還可以交換
			int temp=array[i];
			array[i]=array[0];
			array[0]=temp;
			//System.out.print(temp+"\t");
			maxHeapify(array,i,0);//此處heap_size=i
		}
	}
 

（2）建立最大堆函式採用非遞迴方式：

6.（1）每次把尾節點取出，不做尾節點和根節點交換，直接maxHeapify可以嗎？

解答：不可以，舉個反例當右子樹的值都比左子樹大時，50,14,48,8,7,46,40,3,2