Java堆排序

堆排序的思想：迴圈建立堆，然後交換角標0的節點和角標最後的節點。即排序由兩部分組成，建立堆的滲透函式，和通過迴圈呼叫滲透函式

堆排序是一種樹形選擇排序，是對直接選擇排序的有效改進。

堆的定義如下：具有n個元素的序列（h1,h2,...,hn),當且僅當滿足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）(i=1,2,...,n/2)時稱之為堆。在這裡只討論滿足前者條件的堆。由堆的定義可以看出，堆頂元素（即第一個元素）必為最大項（大頂堆）。完全二叉樹可以很直觀地表示堆的結構。堆頂為根，其它為左子樹、右子樹。初始時把要排序的數的序列看作是一棵順序儲存的二叉樹，調整它們的儲存序，使之成為一個堆，這時堆的根節點的數最大。然後將根節點與堆的最後一個節點交換。然後對前面(n-1)個數重新調整使之成為堆。依此類推，直到只有兩個節點的堆，並對它們作交換，最後得到有n個節點的有序序列。從演算法描述來看，堆排序需要兩個過程，一是建立堆，二是堆頂與堆的最後一個元素交換位置。所以堆排序有兩個函式組成。一是建堆的滲透函式，二是反覆呼叫滲透函式實現排序的函式。

程式碼如下：

public class Heapsort {  
  
    static int a[]={49,38,65,97,76,13,27,49};  
  
    public static void main(String[] args){
    	heapSort(a);
    }
    //堆排序函式
    public static void heapSort(int[] a){
    	int l = a.length;//記錄陣列長度
    	for(int i=0;i<l-1;i++){//迴圈呼叫建立堆函式建立堆
    		buildHeap(a,l-1-i);//呼叫建立堆函式
    		swap(a,0,l-1-i);//堆建立好後，交換根節點和堆的最後一個節點
    		System.out.println(Arrays.toString(a));
    	}
    }
    //交換元素的函式  
    public static void swap(int[] a,int i,int j){
    	int tmp = a[i];
    	a[i] = a[j];
    	a[j] = tmp;
    }
    //建立堆函式，在陣列a中，從0到lastIndex建立堆
    public static void buildHeap(int[] a,int lastIndex){
    	int l = a.length;//記錄陣列長度
    	for(int j=(lastIndex-1)/2;j>=0;j--){//從lastIndex節點（最後一個節點）的父節點開始迴圈
    		int k = j;//k儲存正在判斷的節點
                //如果當前k節點的子節點存在
    		while(2*k+1 <= lastIndex){
    			int biggerIndex = 2*k+1;//k節點的左子節點索引
    			if(biggerIndex < lastIndex){//表示k節點存在右節點
    				if(a[biggerIndex] < a[biggerIndex+1]){
    					biggerIndex++;//biggerIndex總是記錄較大子節點的索引
    				}
    			}
    			if(a[k] < a[biggerIndex]){//如果k節點的值小於較大子節點的值，則交換它們的值，並將biggerIndex賦值給k，開始下一次迴圈
    				swap(a,k,biggerIndex);//保證k節點的值大於其子節點的值
    				k = biggerIndex; //賦值
	    		}else{
	    			break;
	    		}
    		}
    	}
    	
    }
}  
 

[38, 76, 65, 49, 49, 13, 27, 97]
[27, 49, 65, 38, 49, 13, 76, 97]
[13, 49, 27, 38, 49, 65, 76, 97]
[13, 49, 27, 38, 49, 65, 76, 97]
[13, 38, 27, 49, 49, 65, 76, 97]
[27, 13, 38, 49, 49, 65, 76, 97]
[13, 27, 38, 49, 49, 65, 76, 97]