將隨意填充的數組排序成堆的形式,然後進行刪除堆的操作，因為堆刪除的永遠是當前堆中最大的，根據這個特性，可以獲取有序的數組
（排成堆）從最後一個父節點開始向下調整,一直到最上面的父節點。
（刪除堆）刪除操作，獲得的是當前最大的值

public class Node {
    private int iData;//既是關鍵字，又是數值
    public Node(int key) {//初始化
        iData=key;
        
    }
    public int getKey() {//訪問關鍵字
        return iData;
    }
    public void
 
 setKey(int id) {//改變關鍵字
        iData=id;
    }

}

//建立堆
public class Heap {
    private Node[] heapArray;//存儲節點的數組
    private int maxSize;//總大小
    private int currentSize;//當前堆的大小
    public Heap(int mx) {
        maxSize=mx;//初始化總大小
        currentSize=0;//初始化當前數據大小0
        heapArray=new Node[maxSize];
    }
    
 
//給指定位置插入節點
    public void insertAt(int index,Node newNode) {
        heapArray[index]=newNode;
    }
    //給當前數據項值加1
    public void incrementSize() {
        currentSize++;
    }
    //刪除一個數據
    public Node remove() {
        Node root=heapArray[0];
        heapArray[0]=heapArray[--currentSize];//將最後一個數據項移到根上
        
 
//向下調整
        trickleDown(0);
        return root;
        
        
    }
    //向下調整
        public void trickleDown(int index) {
            int largeChild;//記錄大的子節點
            Node top=heapArray[index];
            //找到top的位置
            while(index<currentSize/2) {//指針到了最後一層才停止循環
                int leftChild=2*index+1;//左子節點
                int rightChile=leftChild+1;    //右子節點
                if(rightChile<currentSize && heapArray[leftChild].getKey()<heapArray[rightChile].getKey())//有右子節點
                    largeChild=rightChile;
                else
                    largeChild=leftChild;
                if(top.getKey()>=heapArray[largeChild].getKey()) //將要移動的數據項與上面獲得的最大值比較
                    break;
                heapArray[index]=heapArray[largeChild];//將大的關鍵字調整
                index=largeChild;
                
            }
            //最後定位Node top=heapArray[index]
            heapArray[index]=top;
            
        }
    //判斷是否為空
    public boolean isEmpty() {
        return currentSize==0;
    }
    //顯示堆
        public void displayHeap() {
            //以樹狀的形式
            int nBlanks=32;//控制空格
            int itemsPerRow=1;//當前層的個數
            int column=0;//當前層的數量
            int j=0;
            String dots="...............................";
            System.out.println(dots+dots);
            while(currentSize>0) {
                if(column==0) {
                    for(int k=0;k<nBlanks;k++)
                        System.out.print(‘ ‘);
                }
                System.out.print(heapArray[j].getKey());
                if(++j==currentSize)//全部打印完成
                    break;
                if(++column==itemsPerRow) {//當前層打印完
                    nBlanks/=2;
                    itemsPerRow*=2;
                    column=0;
                    System.out.println();
                }else
                    for(int k=0;k<nBlanks*2-2;k++)
                        System.out.print(‘ ‘);
                    
            }
            
            System.out.println("\n"+dots+dots);
            
        }
        public void displayArray() {
            for(int m=0;m<maxSize;m++)
                
                    System.out.print(heapArray[m].getKey()+" ");
                
            System.out.println();
        }
    
    
    

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Test {
    public static void main(String[] agrs) throws IOException{
        int size,j;
        System.out.println("enter number of items:");
        size=getInt();
        Heap theHeap =new Heap(size);
        for(j=0;j<size;j++) {//將隨機數放入先存入堆的數組中
            int random=(int)(java.lang.Math.random()*100);
            Node newNode=new Node(random); 
            theHeap.insertAt(j, newNode);
            theHeap.incrementSize();
        }
        //顯示
        theHeap.displayHeap();
        //排序堆（將一個填充的數組變成堆的形式,然後排序）
        //從最後一個父節點開始調整，一直到根
        for(j=size/2-1;j>=0;j--) {
            theHeap.trickleDown(j);
        }
        System.out.print("heap:");
        theHeap.displayHeap();
        //排序
        for(j=size-1;j>=0;j--) {
            Node biggestNode=theHeap.remove();//取出最大的數據項
            theHeap.insertAt(j, biggestNode);//放入堆的底層數組的倒數節點中
        }
        System.out.println("排序後數組：");
        theHeap.displayArray();
        
        
    
                    
        
        
    }
    public static String getString() throws IOException{
        InputStreamReader isr=new InputStreamReader(System.in);
        BufferedReader br=new BufferedReader(isr);
        return br.readLine();
    }
    public static char getChar() throws IOException{
        return getString().charAt(0);
    }
    public static int getInt() throws IOException{
        return Integer.parseInt(getString());
    }

}

堆（利用堆進行數組排序）-堆排序