007-排序算法-堆排序

一、概述

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

排序方法	时间复杂度（平均）	时间复杂度 （最坏）	时间复杂度（最好）	空间复杂度	稳定性
堆排序	$O(nlogn)$	O(nlogn)	O(nlogn)	O(1)	不稳定

　　在堆的数据结构中，堆中的最大值总是位于根节点（在优先队列中使用堆的话堆中的最小值位于根节点）。堆中定义以下几种操作：

• 最大堆调整（Max Heapify）：将堆的末端子节点作调整，使得子节点永远小于父节点
• 创建最大堆（Build Max Heap）：将堆中的所有数据重新排序
• 堆排序（HeapSort）：移除位在第一个数据的根节点，并做最大堆调整的递归运算
  

1.1、说明

　　 

　　不断将大根堆的堆顶元素与堆尾元素交换，再重建大根堆的过程。将待排序列构建成大根堆，用变量 heapSize 来控制堆的大小，然后不断地 heapify ，直到 heapSize 等于零。在 heapify 的过程中就是先比较子节点的大小，然后比较父节点和子节点的大小，如果最后发现父节点是比子节点大的话跳出 heapify 循环，否则将子节点与父节点交换，并且找到子节点的左孩子，再重复上诉过程，直到左孩子的位置 left 大于 heapSize ，heapify 循环结束.

1.2、代码实现

public class HeapSort {
    public static void heapSort(int [] arr){
        if(arr == null || arr.length < 2){
            return;
        }
        for(int i = 0; i< arr.length; i++){
            heapInsert(arr,i);
        }

        int heapSize = arr.length;
        swap(arr, 0, --heapSize);
        while(heapSize > 0){
            heapify(arr, 0, heapSize);
            swap(arr, 0, --heapSize);
        }
    }

    private static void heapInsert(int[] arr, int index){
        while(arr[index] > arr[(index - 1) / 2]){
            swap(arr, index, (index -1)/2);
            index = (index -1) / 2;
        }
    }

    private static void heapify(int[] arr, int index, int heapSize){
        int left = index * 2 + 1;
        while(left < heapSize){
            int largest = left + 1 < heapSize && arr[left + 1] > arr[left] ? left + 1 : left;
            largest = arr[largest] > arr[index] ? largest : index;
            if(largest == index){
                break;
            }
            swap(arr, largest, index);
            index = largest;
            left = index * 2 +1;
        }
    }

    private static void swap(int[] arr, int i, int j){
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

代码地址：地址 中的algorithm-001-sort中 HeapSort  

发送到