二叉堆与堆排序的简单实现

一、二叉堆

堆有序：
一颗二叉树中每个节点都大于或者等于其两个孩子时，就称为堆有序。
根节点是堆有序的二叉树的最大节点。

堆有序的二叉树可以用指针来表示，
堆有序的完全二叉树除了可以用指针表示外，还可以用数组表示。

二叉堆：
二叉堆是一组堆有序的完全二叉树，并且在数组中按层级存储（不使用数组中0号位置的元素）。
二叉堆可以方便的实现优先队列的各种操作。

对于给定堆中任意的位置k
其父亲的位置：K/2
其两个孩子的位置：2k或者2k+1
这样就可以不使用指针来实现向上查找和向下查找。

二、二叉堆实现

package agheap;

import java.util.ArrayList;

class Node{
    public final int value;
    Node(int value){
        this.value = value;
    }
    public String toString(){
        return "value:"+value;
    }
}
public class BinHeap {
    private static void swap(ArrayList<Node> aryList,int indexA,int indexB){
        Node tmp;
        tmp = aryList.get(indexA);
        aryList.set(indexA, aryList.get(indexB));
        aryList.set(indexB, tmp);
    }
    
    //上浮堆有序化
    private static void swim(ArrayList<Node> aryList,int index) {
        while(index > 1 && aryList.get(index).value > aryList.get(index/2).value){//当前元素非堆顶且大于其父亲，需要上浮调整
            swap(aryList, index, index/2);
            index = index/2;
        }
    }
    
    //下沉堆有序化
    private static void sink(ArrayList<Node> aryList,int index,int high){
        int indexOfMaxChild;
        while(true){
            if (2*index > high) {break;}//ary[2*index]无孩子
            if (2*index == high) {//ary[2*index]有左孩子，此时indexOfMaxChild无选择
                indexOfMaxChild = 2*index;
            }else {//ary[2*index]有左右两孩子，此时indexOfMaxChild有选择
                indexOfMaxChild = aryList.get(2*index).value > aryList.get(2*index+1).value?2*index:2*index+1;
            }
            if (aryList.get(index).value <aryList.get(indexOfMaxChild).value) {//当前ary[index]不满足局部堆有序
                swap(aryList, index, indexOfMaxChild);
            }
            index = indexOfMaxChild;//继续向下迭代
        }
    }
    
    //sink()构造大根堆
    public static void createHeap(ArrayList<Node> aryList){
        int high = aryList.size()-1;
        for (int i = high/2; i > 0; i--) {//从非叶节点开始构造，同时sink()保持堆有序
            sink(aryList, i, high);
        }
    }
    
//    //swim()构造大根堆
//    public static void createHeap(ArrayList<Node> aryList){
//        int high = aryList.size()-1;
//        for (int i = 1; i <= high; i++) {//从索引1位置开始逐个加入，同时swim()保持堆有序
//            swim(aryList, i);
//        }
//    }
    public static void insert(ArrayList<Node> aryList,Node target){
        aryList.add(target);
        swim(aryList, aryList.size()-1);
    }
    //删除堆顶元素
    public static Node deleteMax(ArrayList<Node> aryList){
        int high = aryList.size()-1;
        Node node = null;
        if (high > 0) {
            swap(aryList, 1, high);//将末尾元素和堆顶元素交换
            node = aryList.remove(high);//删除末尾元素
            sink(aryList, 1, high-1);//对堆顶元素重新，使其重新堆有序
        }
        return node;
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            int[] ary = {0,12,9,78,10,30,8,20,12,15};
            ArrayList<Node> aryList = new ArrayList<Node>();
            for (int i = 0; i < ary.length; i++) {
                aryList.add(new Node(ary[i]));
            }
            createHeap(aryList);
            insert(aryList, new Node(5));
//            for(Node node:aryList){
//                System.out.println(node);
//            }
            int size = aryList.size()-1;
            for (int i = 0; i < size; i++) {
                System.out.println(deleteMax(aryList));
            }
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }

}

三、借助二叉堆实现堆排序

    private static void createHeap(int[] ary,int index,int high){
        int indexOfMaxChild;
        while(true){
            if (2*index > high) {break;}//ary[2*index]无孩子
            if (2*index == high) {//ary[2*index]有左孩子，此时indexOfMaxChild无选择
                indexOfMaxChild = 2*index;
            }else {//ary[2*index]有左右两孩子，此时indexOfMaxChild有选择
                indexOfMaxChild = ary[2*index] > ary[2*index+1]?2*index:2*index+1;
            }
            if (ary[index] < ary[indexOfMaxChild]) {//当前ary[index]不满足局部堆有序
                swap(ary, index, indexOfMaxChild);
            }
            index = indexOfMaxChild;//继续向下迭代
        }
    }
    public static void heapSort(int[] ary){
        int high = ary.length-1;
        for (int i = high/2; i > 0; i--) {//从最大的非叶节点开始构造堆，堆顶位置为1，舍弃数组的0位
            createHeap(ary, i, high);
        }
        while(high > 0){
            swap(ary, 1, high);//将大根堆的堆顶元素(最大值)与数组尾部值交换。
            high--;//大根堆的范围缩小一个单位。
            createHeap(ary, 1, high);//重构大根堆。
            
        }
    }