排序算法--------堆排序

1.堆排序百度百科简介

堆排序(Heapsort)是指利用堆积树(堆)这种数据结构所设计的一种排序算法,它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆,是完全二叉树

1548312178822

2.什么是堆

根据《Data Structures and Algorithm Analysis in C》(中文译名:《数据结构与算法分析》)和百度百科的相关资料,必须同时具备两个特性:1、结构性;2)堆序性

2.1 结构性

堆是一棵完全二叉树,所谓完全二叉树即叶节点只能出现在最下层和次下层,并且最下面一层的结点都集中在该层最左边的若干位置的二叉树。

2.2 堆序性

当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆

图解:

在这里插入图片描述

将大根堆逻辑结构映射到数组中图解:
在这里插入图片描述

所以我们就可以称这个数组从逻辑上来讲就是一个堆结构,这种逻辑结构总结公式描述为:

大根堆:arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]

小根堆:arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]

3.堆排序的实现(大根堆实现)

3.1 思想实现

​ 大根堆有一个很好的性质,根节点的数值总是大于其他所有节点的数值,利用这个性质,可以实现排序的工作。堆排序的步骤可以描述如下:

​ 1.构建大根堆。首先我们的原始数组一般情况下是不满足堆的条件,既然我们要可用大根段的性质进行排序,第一步当然是对原始数组进行处理,构建大根堆。

​ 2.根节点数据处理以及大根堆重构。构建了大根堆之后,根节点的数据是最大值,将该数值与数组最后一个进行数据交换,然后对剩下的元素重构大根堆,这时根节点是剩下元素的最大值,取出。只要不断重复上述的操作,不断取出未排序元素的最大值,直到未排序的元素只剩一个,就完成了排序工作。

3.2 实现图解

3.2.1 一个例子的gif图解

在这里插入图片描述

3.2.2 详细举例

下面演示将数组{20,30,90,40,70,110,60,10,100,50,80}转换为最大{110,100,90,40,80,20,60,10,30,50,70}的步骤。

第一步:构建大根堆

1.i=11/2-1,即i=4

在这里插入图片描述

上面是maxHeapDown(a, 4, 9)调整过程。maxHeapDown(a, 4, 9)的作用是将a[4…9]进行下调;a[4]的左孩子是a[9],右孩子是a[10]。调整时,选择左右孩子中较大的一个(即a[10])和a[4]交换。

注:maxHeapDown为最大堆的向下调整算法 ,下面代码实现中定义的方法!

2.i=3

在这里插入图片描述

上面是maxHeapDown(a, 3, 9)调整过程。maxHeapDown(a, 3, 9)的作用是将a[3…9]进行下调;a[3]的左孩子是a[7],右孩子是a[8]。调整时,选择左右孩子中较大的一个(即a[8])和a[4]交换。

3.i=2

在这里插入图片描述
上面是maxHeapDown(a, 2, 9)调整过程。maxHeapDown(a, 2, 9)的作用是将a[2…9]进行下调;a[2]的左孩子是a[5],右孩子是a[6]。调整时,选择左右孩子中较大的一个(即a[5])和a[2]交换。

4.i=1

在这里插入图片描述
上面是maxHeapDown(a, 1, 9)调整过程。maxHeapDown(a, 1, 9)的作用是将a[1…9]进行下调;a[1]的左孩子是a[3],右孩子是a[4]。调整时,选择左右孩子中较大的一个(即a[3])和a[1]交换。交换之后,a[3]为30,它比它的右孩子a[8]要大,接着,再将它们交换。

5.i=0

在这里插入图片描述
上面是maxHeapDown(a, 0, 9)调整过程。maxHeapDown(a, 0, 9)的作用是将a[0…9]进行下调;a[0]的左孩子是a[1],右孩子是a[2]。调整时,选择左右孩子中较大的一个(即a[2])和a[0]交换。交换之后,a[2]为20,它比它的左右孩子要大,选择较大的孩子(即左孩子)和a[2]交换。

调整完毕,就得到了最大堆。此时,数组{20,30,90,40,70,110,60,10,100,50,80}也就变成了{110,100,90,40,80,20,60,10,30,50,70}。

第二步:交换数据

在将数组转换成最大堆之后,接着要进行交换数据,从而使数组成为一个真正的有序数组。
交换数据部分相对比较简单,下面仅仅给出将最大值放在数组末尾的示意图。

在这里插入图片描述

上面是当n=10时,交换数据的示意图。
当n=10时,首先交换a[0]和a[10],使得a[10]是a[0…10]之间的最大值;然后,调整a[0…9]使它称为最大堆。交换之后:a[10]是有序的!
当n=9时, 首先交换a[0]和a[9],使得a[9]是a[0…9]之间的最大值;然后,调整a[0…8]使它称为最大堆。交换之后:a[9…10]是有序的!

依此类推,直到a[0…10]是有序的。

4.java代码实现

public class HeapSort {
    /*
     * (最大)堆的向下调整算法
     *
     * 注:数组实现的堆中,第N个节点的左孩子的索引值是(2N+1),右孩子的索引是(2N+2)。
     *     其中,N为数组下标索引值,如数组中第1个数对应的N为0。
     *
     * 参数说明:
     *     a -- 待排序的数组
     *     start -- 被下调节点的起始位置(一般为0,表示从第1个开始)
     *     end   -- 截至范围(一般为数组中最后一个元素的索引)
     */
    public static void maxHeapDown(int[] a, int start, int end) {
        // 当前(current)节点的位置
        int c = start;
        // 左(left)孩子的位置
        int l = 2*c + 1;
        // 当前(current)节点的大小
        int tmp = a[c];

        for (; l <= end; c=l,l=2*l+1) {
            // "l"是左孩子,"l+1"是右孩子
            if ( l < end && a[l] < a[l+1]) {
                l++;        // 左右两孩子中选择较大者,即m_heap[l+1]
            }
            if (tmp >= a[l]) {
                break;        // 调整结束
            } else {            // 交换值
                a[c] = a[l];
                a[l]= tmp;
            }
        }
    }

    /*
     * 堆排序(从小到大)
     *
     * 参数说明:
     *     a -- 待排序的数组
     *     n -- 数组的长度
     */
    public static void heapSortAsc(int[] a, int n) {
        int i,tmp;

        // 从(n/2-1) --> 0逐次遍历。遍历之后,得到的数组实际上是一个(最大)二叉堆。
        for (i = n / 2 - 1; i >= 0; i--) {
            maxHeapDown(a, i, n-1);
        }

        // 从最后一个元素开始对序列进行调整,不断的缩小调整的范围直到第一个元素
        for (i = n - 1; i > 0; i--) {
            // 交换a[0]和a[i]。交换后,a[i]是a[0...i]中最大的。
            tmp = a[0];
            a[0] = a[i];
            a[i] = tmp;
            // 调整a[0...i-1],使得a[0...i-1]仍然是一个最大堆。
            // 即,保证a[i-1]是a[0...i-1]中的最大值。
            maxHeapDown(a, 0, i-1);
        }
    }

    /*
     * (最小)堆的向下调整算法
     *
     * 注:数组实现的堆中,第N个节点的左孩子的索引值是(2N+1),右孩子的索引是(2N+2)。
     *     其中,N为数组下标索引值,如数组中第1个数对应的N为0。
     *
     * 参数说明:
     *     a -- 待排序的数组
     *     start -- 被下调节点的起始位置(一般为0,表示从第1个开始)
     *     end   -- 截至范围(一般为数组中最后一个元素的索引)
     */
    public static void minHeapDown(int[] a, int start, int end) {
        // 当前(current)节点的位置
        int c = start;
        // 左(left)孩子的位置
        int l = 2*c + 1;
        // 当前(current)节点的大小
        int tmp = a[c];

        for (; l <= end; c=l,l=2*l+1) {
            // "l"是左孩子,"l+1"是右孩子
            if ( l < end && a[l] > a[l+1]) {
                l++;        // 左右两孩子中选择较小者
            }
            if (tmp <= a[l]) {
                break;        // 调整结束
            } else {            // 交换值
                a[c] = a[l];
                a[l]= tmp;
            }
        }
    }

    /*
     * 堆排序(从大到小)
     *
     * 参数说明:
     *     a -- 待排序的数组
     *     n -- 数组的长度
     */
    public static void heapSortDesc(int[] a, int n) {
        int i,tmp;

        // 从(n/2-1) --> 0逐次遍历每。遍历之后,得到的数组实际上是一个最小堆。
        for (i = n / 2 - 1; i >= 0; i--) {
            minHeapDown(a, i, n-1);
        }

        // 从最后一个元素开始对序列进行调整,不断的缩小调整的范围直到第一个元素
        for (i = n - 1; i > 0; i--) {
            // 交换a[0]和a[i]。交换后,a[i]是a[0...i]中最小的。
            tmp = a[0];
            a[0] = a[i];
            a[i] = tmp;
            // 调整a[0...i-1],使得a[0...i-1]仍然是一个最小堆。
            // 即,保证a[i-1]是a[0...i-1]中的最小值。
            minHeapDown(a, 0, i-1);
        }
    }

    public static void main(String[] args) {
        int i;
        int a[] = {20,30,90,40,70,110,60,10,100,50,80};

        System.out.printf("堆排序前:");
        for (i=0; i<a.length; i++) {
            System.out.printf("%d ", a[i]);
        }
        System.out.printf("\n");
        // 升序排列
        heapSortAsc(a, a.length);
        // 降序排列
        //heapSortDesc(a, a.length);

        System.out.printf("堆排序后:");
        for (i=0; i<a.length; i++) {
            System.out.printf("%d ", a[i]);
        }
        System.out.printf("\n");
    }
}

运行结果:

1548315550680
版权声明:本博客为记录本人自学感悟,转载需注明出处!
https://me.csdn.net/qq_39657909

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 技术黑板 设计师:CSDN官方博客 返回首页