算法系列之--Javascript和Kotlin的堆排序算法（原）

        上一节我们学习了希尔排序算法，这一节来学习堆排序算法，算法系列文章目录在这里。

介绍

        堆排序算法是基于堆这种数据结构设计的算法，理解了堆的概念就明白了堆算法的原理，因此我们简单介绍一下堆的数据结构。

        堆的结构主要有以下几个特征：

        1. 堆是由一个个小堆构成的，每个堆中，父节点都大于两个子节点，但是两个子节点的大小没有要求，既可以左子节点>右子节点，又可以右子节点>左子节点

        2. 堆可以由数组来模拟，对于某个节点来说，他的父子关系与数组索引的关系如下：

            父节点i的左子节点在位置(2*i+1);

            父节点i的右子节点在位置(2*i+2);

            子节点i的父节点在位置floor((i-1)/2);

        3. 由于堆顶就是当前数列的最大值，因此可以依次拿出堆顶的方法来实现排序

        利用堆排序的步骤如下：

        1. 建立最大堆的模型

        2. 将堆顶元素与最后一位元素交换位置

        3. 重新建立列表0到len-1之间的最大堆模型

        4. 重复步骤2、3，这样的话最大的元素就会以此放在整个堆的最后面，从而实现排序

特点

        平均、最好、最坏都是O(n log n)，但是时间常数大于快排，所以效率会稍微低于快速排序

效率

        平均时间复杂度O(n log n)

        最坏时间复杂度O(n log n)

        最优时间复杂度O(n log n)

源码

Js源码

let list = [123456, 4, 8, 23, 5, 13, 323, 1, 9, 2, 3]let swap = function (x, y) {    let temp = list[x]    list[x] = list[y]    list[y] = temp}let max_heapify = function (start, end) {    if (start >= end) {        return    }    let dad = start    let son = dad * 2 + 1    if (son >= end) {        //儿子索引已经超过数组最大索引        return    }    if (son + 1 < end && list[son] < list[son + 1]) {        //说明两个儿子之间右边的更大        son++    }    if (list[dad] <= list[son]) {        //交换父子        swap(dad, son)        //因为父子交换了，因此该分支下面所有堆都要重排        //并且索引从当前换位的son开始直到该分支最后一位元素        max_heapify(son, end)    }}let len = list.lengthfor (let i = Math.floor(len / 2) - 1; i >= 0; i--) {    //这一步的作用就是建立最大堆模型    //这里选出来的i，就是当前堆的最后一个三角的单位中的爸爸，也就是说从最后一个单元开始向上递增构建最大堆    max_heapify(i, len)}for (let i = len - 1; i > 0; i--) {    //依次拿出堆顶元素放在数列最后    swap(0, i)    //对剩余的0-->i的堆重拍，即可找到剩余数列中的最大值    max_heapify(0, i)}

Kotlin源码

private var ARRAY_COUNT = 100000/* * 获取随机数列 */private fun getSortList(): IntArray {    var sortList = IntArray(ARRAY_COUNT)    var ra = Random()    for (i in sortList.indices) {        sortList[i] = ra.nextInt(ARRAY_COUNT * 10)    }    return sortList}/* * 交换数列元素 */private fun swapByIndex(list: IntArray, x: Int, y: Int) {    var temp = list[x]    list[x] = list[y]    list[y] = temp}/* * 建立最大堆模型 */private fun loopForDui(list: IntArray, start: Int, end: Int) {    if (start >= end) {        return    }    var dad = start    var son = dad * 2 + 1    if (son >= end) {        //儿子索引已经超过数组最大索引        return    }    if (son + 1 < end && list[son] < list[son + 1]) {        //说明两个儿子之间右边的更大        son++    }    if (list[dad] <= list[son]) {        //交换父子        swapByIndex(list, dad, son)        //因为父子交换了，因此该分支下面所有堆都要重排        //并且索引从当前换位的son开始直到该分支最后一位元素        loopForDui(list, son, end)    }}private fun dui() {    var sortList = getSortList()    var len = sortList.size    for (i in len / 2 - 1 downTo 0) {        //这一步的作用就是建立最大堆模型        //这里选出来的i，就是当前堆的最后一个三角的单位中的爸爸，也就是说从最后一个单元开始向上递增构建最大堆        loopForDui(sortList, i, len)    }    for (i in len - 1 downTo 1) {        //依次拿出堆顶元素放在数列最后        swapByIndex(sortList, 0, i)        //对剩余的0-->i的堆重拍，即可找到剩余数列中的最大值        loopForDui(sortList, 0, i)    }}

        下一节我们来学习一种非比较思想设计的高效的排序算法----基数排序算法

        各个算法的Kotlini版本性能测试结果请看《算法系列之--Kotlin的算法实战比较》