Java堆排序（HeapSort）算法实现

算法实现

public class MaxHeap {
    public static int left(int i){
        return 2*i;
    }
    public static int right(int i){
        return 2*i+1;
    }
    public static int heapSize(int [] arr){
        return arr.length;
    }
    //维护最大堆性质，考虑一个有两个节点的树
    public static void maxHeapify(int [] arr,int i,int heapSize){
        int l = left(i);
        int r = right(i);
        int largest = i;
        int tmp = -1;
        //如果左孩子大于根节点，则调换
        if(l <= heapSize&&arr[l-1]>arr[i-1])
            largest = l;
        //如果有孩子大于当前最大的节点，即子节点和根节点，则调换
        if(r <= heapSize&&arr[r-1]>arr[largest-1])
            largest = r;
        //实际调换程序
        if(largest != i){
            tmp = arr[i-1];
            arr[i-1] = arr[largest-1];
            arr[largest-1]= tmp;
            maxHeapify(arr,largest,heapSize);
        }
    }
    //自底向上建立最大堆，由于下标大于2*i+1的节点没有子节点，从2*i开始逐渐建立最大堆
    public static void buildMaxHeap(int[] arr){
        for(int i=heapSize(arr)/2;i>0;i--){
            maxHeapify(arr,i,heapSize(arr));
        }
    }

    //首先建立最大堆，每次将堆顶元素与最后一个元素交换后，重新维护最大堆性质，进行n-1次
    public static void heapSort(int [] arr){
        buildMaxHeap(arr);
        int heapSize = heapSize(arr);
        int tmp = -1;
        for(int i=heapSize-1;i > 0;i--){
            tmp = arr[0];
            arr[0] = arr[i];
            arr[i] = tmp;

            heapSize--;
            maxHeapify(arr,1,heapSize);
        }
    }
    public static void main(String []args){
        int [] innerArr = {4,1,3,2,16,9,10,14,8,7};
        heapSort(innerArr);
        for(int e:innerArr){
            System.out.println(e);
        }
    }
}

运行时间

T(n) = O(nlgn)