堆排序

一.简介

堆排序（英语：Heapsort）是利用堆这种数据结构所设计的一种排序算法。堆是一个完全二叉树的结构，并满足堆积的性质：子结点的值总是小于（或者大于）它的父节点。

大顶堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]

小顶堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]

二.实现

package com.vincent.main;

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
        int[] arr = new int[32];
        for(int i=0;i<arr.length;i++) {
            arr[i] = (int)(Math.random() * 100);
        }
        System.out.println(Arrays.toString(arr));
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 堆排序
     * @param arr
     */
    public static void heapSort(int[] arr) {
        //从最后一个父节点开始构建大顶堆
        for(int k=(arr.length-1)/2;k>=0;k--) {
            heapify(arr,k,arr.length);
        }
        //数组倒序索引元素被赋予大顶堆最大值
        for(int i=arr.length-1;i>=0;i--) {
            int tmp = arr[i];
            arr[i] = arr[0];
            arr[0] = tmp;

            heapify(arr,0,i);
        }
    }

    /**
     * 调整index 索引的节点为大顶堆
     * @param arr
     * @param index     节点索引
     * @param endIndex  节点的最大索引值,不包含
     */
    private static void heapify(int[] arr,int index,int endIndex) {
        int maxIndex = index;
        int lIndex = 2*index+1;

        if(lIndex<arr.length && lIndex<endIndex && arr[maxIndex] < arr[lIndex]) {
            maxIndex = lIndex;
        }
        if(lIndex+1<arr.length && lIndex+1<endIndex && arr[maxIndex] < arr[lIndex+1]) {
            maxIndex = lIndex+1;
        }
        if(maxIndex != index) {
            int tmp = arr[index];
            arr[index] = arr[maxIndex];
            arr[maxIndex] = tmp;

            //继续调整子节点满足大顶堆
            heapify(arr, maxIndex,endIndex);
        }
    }

}

效果:

三.总结

堆排序时间复杂度：O(nlogn)