不得不知的排序六:堆排序

Posted 编程技术圈

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了不得不知的排序六:堆排序相关的知识,希望对你有一定的参考价值。


每日英文
Sometimes we want things to be different,we think maybe if we pretend that they are,fool people,that’s enough,but it never is.
有时候我们希望事情有所改变,觉得如果我们假装那是我们想要的,欺骗别人 ,那样就行了,但事实上不是。


乐乐有话说
堆积了多少无可奈何与无能为力,才会想通和顺其自然。


来自:静默虚空

链接:cnblogs.com/jingmoxukong/p/4303826.html


图片来自网络

0 排序算法系列


1 堆的概念

在介绍堆排序之前,首先需要说明一下,堆是个什么玩意儿。

堆是一棵顺序存储的完全二叉树。

其中每个结点的关键字都不大于其孩子结点的关键字,这样的堆称为小根堆。

其中每个结点的关键字都不小于其孩子结点的关键字,这样的堆称为大根堆。

举例来说,对于n个元素的序列{R0, R1, … , Rn}当且仅当满足下列关系之一时,称之为堆:

(1) Ri <= R2i+1 且 Ri <= R2i+2 (小根堆)

(2) Ri >= R2i+1 且 Ri >= R2i+2 (大根堆)

其中i=1,2,…,n/2向下取整;

不得不知的排序六:堆排序

如上图所示,序列R{3, 8, 15, 31, 25}是一个典型的小根堆。

堆中有两个父结点,元素3和元素8。

元素3在数组中以R[0]表示,它的左孩子结点是R[1],右孩子结点是R[2]。

元素8在数组中以R[1]表示,它的左孩子结点是R[3],右孩子结点是R[4],它的父结点是R[0]。可以看出,它们满足以下规律:

设当前元素在数组中以R[i]表示,那么,

(1) 它的左孩子结点是:R[2*i+1];

(2) 它的右孩子结点是:R[2*i+2];

(3) 它的父结点是:R[(i-1)/2];

(4) R[i] <= R[2*i+1] 且 R[i] <= R[2i+2]。

2 要点

首先,按堆的定义将数组R[0..n]调整为堆(这个过程称为创建初始堆),交换R[0]和R[n];

然后,将R[0..n-1]调整为堆,交换R[0]和R[n-1];

如此反复,直到交换了R[0]和R[1]为止。

以上思想可归纳为两个操作:

(1)根据初始数组去构造初始堆(构建一个完全二叉树,保证所有的父结点都比它的孩子结点数值大)。

(2)每次交换第一个和最后一个元素,输出最后一个元素(最大值),然后把剩下元素重新调整为大根堆。

当输出完最后一个元素后,这个数组已经是按照从小到大的顺序排列了。

先通过详细的实例图来看一下,如何构建初始堆。

设有一个无序序列 { 1, 3, 4, 5, 2, 6, 9, 7, 8, 0 }。

不得不知的排序六:堆排序

构造了初始堆后,我们来看一下完整的堆排序处理:

还是针对前面提到的无序序列 { 1, 3, 4, 5, 2, 6, 9, 7, 8, 0 } 来加以说明。

不得不知的排序六:堆排序

相信,通过以上两幅图,应该能很直观的演示堆排序的操作处理。

核心代码

public void HeapAdjust(int[] arrayint parent, int length) {
    int temp = array[parent]; // temp保存当前父节点
    int child = 2 * parent + 1// 先获得左孩子

    while (child < length) {
        // 如果有右孩子结点,并且右孩子结点的值大于左孩子结点,则选取右孩子结点
        if (child + 1 < length && array[child] < array[child + 1]) {
            child++;
        }

        // 如果父结点的值已经大于孩子结点的值,则直接结束
        if (temp >= array[child])
            break;

        // 把孩子结点的值赋给父结点
        array[parent] = array[child];

        // 选取孩子结点的左孩子结点,继续向下筛选
        parent = child;
        child = 2 * child + 1;
    }

    array[parent] = temp;
}

public void heapSort(int[] list) {
    // 循环建立初始堆
    for (int i = list.length / 2; i >= 0; i--) {
        HeapAdjust(list, i, list.length);
    }

    // 进行n-1次循环,完成排序
    for (int i = list.length - 1; i > 0; i--) {
        // 最后一个元素和第一元素进行交换
        int temp = list[i];
        list[i] = list[0];
        list[0] = temp;

        // 筛选 R[0] 结点,得到i-1个结点的堆
        HeapAdjust(list0, i);
        System.out.format("第 %d 趟: \t"list.length - i);
        printPart(list0list.length - 1);
    }
}
3 算法分析


 堆排序算法的总体情况


不得不知的排序六:堆排序

 时间复杂度

堆的存储表示是顺序的。因为堆所对应的二叉树为完全二叉树,而完全二叉树通常采用顺序存储方式。

当想得到一个序列中第k个最小的元素之前的部分排序序列,最好采用堆排序。

因为堆排序的时间复杂度是O(n+klog2n),若k≤n/log2n,则可得到的时间复杂度为O(n)。

 算法稳定性

堆排序是一种不稳定的排序方法。

因为在堆的调整过程中,关键字进行比较和交换所走的是该结点到叶子结点的一条路径,

因此对于相同的关键字就可能出现排在后面的关键字被交换到前面来的情况。

4 完整参考代码

 JAVA版本

代码实现

以下范例是对上文提到的无序序列 { 1, 3, 4, 5, 2, 6, 9, 7, 8, 0 } 进行排序。

public class HeapSort {

    public void HeapAdjust(int[] arrayint parent, int length) {
        int temp = array[parent]; // temp保存当前父节点
        int child = 2 * parent + 1// 先获得左孩子

        while (child < length) {
            // 如果有右孩子结点,并且右孩子结点的值大于左孩子结点,则选取右孩子结点
            if (child + 1 < length && array[child] < array[child + 1]) {
                child++;
            }

            // 如果父结点的值已经大于孩子结点的值,则直接结束
            if (temp >= array[child])
                break;

            // 把孩子结点的值赋给父结点
            array[parent] = array[child];

            // 选取孩子结点的左孩子结点,继续向下筛选
            parent = child;
            child = 2 * child + 1;
        }

        array[parent] = temp;
    }

    public void heapSort(int[] list) {
        // 循环建立初始堆
        for (int i = list.length / 2; i >= 0; i--) {
            HeapAdjust(list, i, list.length);
        }

        // 进行n-1次循环,完成排序
        for (int i = list.length - 1; i > 0; i--) {
            // 最后一个元素和第一元素进行交换
            int temp = list[i];
            list[i] = list[0];
            list[0] = temp;

            // 筛选 R[0] 结点,得到i-1个结点的堆
            HeapAdjust(list0, i);
            System.out.format("第 %d 趟: \t"list.length - i);
            printPart(list0list.length - 1);
        }
    }

    // 打印序列
    public void printPart(int[] listint begin, int end) {
        for (int i = 0; i < begin; i++) {
            System.out.print("\t");
        }
        for (int i = begin; i <= end; i++) {
            System.out.print(list[i] + "\t");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        // 初始化一个序列
        int[] array = {
                1345269780
        };

        // 调用快速排序方法
        HeapSort heap = new HeapSort();
        System.out.print("排序前:\t");
        heap.printPart(array0array.length - 1);
        heap.heapSort(array);
        System.out.print("排序后:\t");
        heap.printPart(array0array.length - 1);
    }
}

运行结果

排序前:    1   3   4   5   2   6   9   7   8   0 
 

第 1 趟:   8   7   6   5   2   1   4   3   0   9  
第 2 趟:   7   5   6   3   2   1   4   0   8   9  
第 3 趟:   6   5   4   3   2   1   0   7   8   9  
第 4 趟:   5   3   4   0   2   1   6   7   8   9  
第 5 趟:   4   3   1   0   2   5   6   7   8   9  
第 6 趟:   3   2   1   0   4   5   6   7   8   9  
第 7 趟:   2   0   1   3   4   5   6   7   8   9  
第 8 趟:   1   0   2   3   4   5   6   7   8   9  
第 9 趟:   0   1   2   3   4   5   6   7   8   9  

排序后:    0   1   2   3   4   5   6   7   8   9  


如果您觉得不错,请别忘了转发、分享、点赞让更多的人去学习, 您的举手之劳,就是对小乐最好的支持,非常感谢!



   
     
     
   
      
        
        
      
推荐阅读




   
     
     
   

看完本文有收获?请转发分享给更多人
关注「程序员小乐」,提升技能

以上是关于不得不知的排序六:堆排序的主要内容,如果未能解决你的问题,请参考以下文章

不得不知的排序二:直接插入排序

不得不知的排序无:简单选择排序

不得不知的排序一:冒泡排序

不得不知的排序四:希尔排序

不得不知的排序三:直接插入排序

不得不知的排序八:基数排序