基于树的堆移除根节点实现排序

基于树的堆移除根节点也可以实现排序

package org.exam.ch12.sort;

/**
 * Created by xin on 15.10.17.
 */
class Node{
    private int key;
    public Node() {
    }
    public Node(int key) {
        this.key = key;
    }
    public int getKey() {
        return key;
    }
    public void setKey(int key) {
        this.key = key;
    }
}
class Heap{
    private Node[] arr;
    private int currentSize;
    private int maxSize;
    public Heap(int maxSize) {
        this.maxSize = maxSize;
        arr=new Node[maxSize];
    }
    public boolean isEmpty(){
        return currentSize==0;
    }
    public void insert(int key){
        arr[currentSize++]=new Node(key);
    }
    public void toBeHeap(){
        for (int i = currentSize/2-1; i>=0 ; i--) {
            trickleDown(i);
        }
    }
    public void sort(){
        for (int i = currentSize-1; i >=0 ; i--) {
            int key=remove().getKey();
            arr[i]=new Node(key);//这里不要用arr[i].setKey(key).因为arr[i]可能会与其它数组元素(比如arr[0])共同引用同一个节点.所以改变节点时，arr[0]也是指同这个节点，这样看起来,它也变了.
        }
    }
    public Node remove(){//每次只删除根节点(根节点数据是最大的),并将根节点返回
        Node root=arr[0];
        arr[0]=arr[--currentSize];//将arr[0]指向最后一个节点,看起来就是将最后一个节点变成根节点.
        trickleDown(0);
        return root;//将删除的根节点返回
    }
    private void trickleUp(int index) {
        Node bottom=arr[index];//先缓存此节点
        int parent=(index-1)/2;//由子获取父索引
        while (index>0&&arr[parent].getKey()<bottom.getKey()){
            arr[index]=arr[parent];//将arr[index]指向arr[parent]的指向的节点
            index=parent;
            parent=(parent-1)/2;//这两步为改为下次的arr[index]将准备
        }
        arr[index]=bottom;//最后将arr[index]指向原先缓存的节点
    }
    private void trickleDown(int index) {
        Node top=arr[index];//先缓存此节点
        int largerChild;//将父节点，左右子节点三者比较，用于临时保存
        while (index<currentSize/2){//当到达最后一层,当然不用交换
            int leftChild=2*index+1;
            int rightChild=leftChild+1;
            if (rightChild<currentSize&&arr[leftChild].getKey()<arr[rightChild].getKey()){//先比较左右子节点
                largerChild=rightChild;
            }else{
                largerChild=leftChild;
            }
            if (top.getKey()>=arr[largerChild].getKey()){
                break;//如果父节点不小于子节点，就退出循环.
            }
            arr[index]=arr[largerChild];//将arr[index]指向arr[largerChild]指向的节点
            index=largerChild;//为下次交换做准备
        }
        arr[index]=top;
    }
    public void displayArray(){
        System.out.println("Heap Array:");
        for (int i = 0; i < maxSize; i++) {
            if (arr[i]!=null){
                System.out.print(arr[i].getKey() + "  ");
            }else{
                System.out.print("--");
            }
        }
        System.out.println();
    }
    public void displayHeap() {
        int nBlanks = 32;
        int itemsPerRow = 1;
        int column = 0;
        int j = 0;                          // current item
        String dots = "...............................";
        System.out.println(dots + dots);      // dotted top line

        while (currentSize > 0)              // for each heap item
        {
            if (column == 0)                  // first item in row?
                for (int k = 0; k < nBlanks; k++)  // preceding blanks
                    System.out.print(' ');
            // display item
            System.out.print(arr[j].getKey());

            if (++j == currentSize)           // done?
                break;

            if (++column == itemsPerRow)        // end of row?
            {
                nBlanks /= 2;                 // half the blanks
                itemsPerRow *= 2;             // twice the items
                column = 0;                   // start over on
                System.out.println();         //    new row
            } else                             // next item on row
                for (int k = 0; k < nBlanks * 2 - 2; k++)
                    System.out.print(' ');     // interim blanks
        }  // end for
        System.out.println("\n" + dots + dots); // dotted bottom line
    }
}

public class HeadSortApp {
    public static void main(String[] args) {
        int maxSize=15;
        Heap heap=new Heap(maxSize);
        for (int i = 0; i < maxSize; i++) {
            int key= (int) (Math.random()*100);
            heap.insert(key);
        }
        heap.displayHeap();
        heap.toBeHeap();
        heap.displayHeap();
        heap.sort();
        heap.displayArray();

    }
}