码迷,mamicode.com
首页 > 其他好文 > 详细

堆的简单学习

时间:2020-07-03 12:14:54      阅读:54      评论:0      收藏:0      [点我收藏+]

标签:插入   结果   void   length   技术   private   count   index   总结   

书本上只介绍到堆排序,无细讲堆,翻烂 ??掘金,找到一篇不错的图文介绍(https://juejin.im/post/5ec25b156fb9a0435a01e52e)

1. 堆

二叉树可以被细分为普通二叉树、满二叉树、完全二叉树,而今天所分享的堆这种数据结构就是一种完全二叉树

堆中的每个结点的值要么都大于左右子结点的值,要么都小于左右子结点的值。前者形成的是大顶堆,即堆顶元素是最大的;后者形成的是小顶堆,即堆顶元素是最小的。如下图所示,分表是一个大顶堆和小顶堆。

技术图片

完全二叉树的特点是:最后一层的叶子结点靠左排列,从根结点到倒数第二层结点,是一颗满二叉树。通常储存二叉树这种数据结构的方法有链式存储和顺序存储,链式存储就是通过指针来维护左右子结点的关系,而顺序存储就是利用数组来存储。完全二叉树最适合用数组来存储,即堆这种数据结构适合用数组来存储。

当用数组来存放堆元素时,如果堆顶的元素存放在索引为 1 的地方(不从 0 开始),那么左节点的索引为 2,右结点的索引为 3。也就是是说,如果父结点存放在数组索引为 i 的地方,那么左结点存放的位置为 2i,右结点存放的位置为 2i+1。

下面看下堆的常用操作:插入数据和删除堆顶数据

1.1 插入数据

以大顶堆为例,当向堆中插入数据时,新插入的数据首先放在数组的最后面,由于是大顶堆,而新插入的数据可能比父结点的值大,因此会出现不满足大顶堆性质的情况,这个时候需要调整数据的位置,这个过程,叫做堆化(heapify)。(堆化分两种:「向下堆化和向上堆化」,此时是向上堆化)技术图片

下面看下代码实现。

public class Heap {

    private int[] heap; // 存放数据
    private int capacity;   // 堆的最大容量
    private int count;  // 堆中目前存放的数据个数

    public Heap(int capacity) {
        this.heap = new int[capacity + 1];    // 数组下标为0的地方不存放元素(这样计算左右子结点的位置的时候,方便表示)
        this.capacity = capacity;
        this.count = 0;
    }

    public void insert(int data) {
        if (count >= capacity) return; // 堆满了
        count++;
        heap[count] = data;
        int i = count;
        while (i / 2 > 0 && heap[i] > heap[i / 2]) {    // 如果子结点的数据比父结点大,就堆化,交换位置
            swap(heap, i, i / 2);    // 交换数据
            i = i / 2;
        }
    }

    // 交换下标a1和下标a2的数据
    private static void swap(int[] heap, int a1, int a2) {
        // 不借助额外的内存空间,来交换两个数
        heap[a1] = heap[a1] ^ heap[a2];
        heap[a2] = heap[a1] ^ heap[a2];
        heap[a1] = heap[a1] ^ heap[a2];
        /**
         * 上面三行代码等价于这几行代码
         * int tmp = heap[a2];
         * heap[a2] = heap[a1];
         * heap[a1] = tmp
         */
    }

}

1.2 删除堆顶数据

还是以大顶堆为例,当要删除堆中最大的元素时,其实就是删除堆顶元素。删除完堆顶元素后,需要从堆中找出一个最大的元素放到堆顶。这个时候,通常是将数组中最后一个数据放到堆顶,由于这个数据可能不是最大的,因此也需要进行堆化,此时通常采用向下堆化的手段。代码实现如下:

// 删除最大元素
public void deleteMax() {
    if (count == 0) return; // 空堆
    heap[1] = heap[count];
    count--;
    heapify(heap, 1, count);   // 从上往下堆化
}

// 堆化
private static void heapify(int[] heap, int i, int count) {
    while (2 * i <= count) {
        int maxIndex = i;
        if (heap[i] < heap[2 * i]) maxIndex = 2 * i;     // 和左结点比较
        if ((2 * i + 1) <= count && heap[2 * i + 1] > heap[2 * i]) maxIndex = 2 * i + 1;    // 如果右结点更大,则和右结点交换
        if (maxIndex == i) return;  // 如果左右子结点均小于当前结点,就表示不需要堆化了,直接返回
        swap(heap, i, maxIndex);    // 交换数据
        i = maxIndex;
    }
}

2. 堆排序

堆顶的元素要么是最大的,要么是最小的,如果我们每次从堆顶取一个元素,那么每次取到的数据就是最大或者最小,依次取完,那么取出来的数据就是有序的了。

使用堆排序有一个优点,就是「不需要额外的内存空间」,直接基于原数组,就可以完成排序操作。

堆排序大概分为两个步骤:「建堆和排序」。建堆是指根据指定的数组,将其变为满足堆这种数据结构的数据。建堆的思路有两种,一种是从下往上建堆(前面的插入数据过程就是从下往上建堆),一种是从上往下建堆。下面以从上往下建堆为例,构建一个大顶堆,示例代码如下。

// 建堆(从上往下建堆)
public static int[] buildHeap(int[] a) {
    int length = a.length;
    // 数组a的下标为0的地方不存放元素
    for (int i = length / 2; i >= 1; i--) {  // 叶子结点不需要堆化,因为叶子结点下面是没有左右子结点的,无法向下堆化
        heapify(a, i, length - 1);
    }
    return a;
}

在从上往下建堆的过程中,叶子结点是不需要堆化,因为叶子结点下面是没有左右子结点的,无法向下堆化。

接下来是排序过程,排序过程中,由于是大顶堆,所以将堆顶元素与数组最后的元素交换,然后刨去数组最后一个元素,将剩余元素进行堆化,循环遍历,这样数组就是变成从小到大排列的有序数组了。示例代码如下:

// 排序
public static void sort(int[] a) {
    a = buildHeap(a);   // 先建堆
    int i = a.length - 1;
    while (i > 1) {
        swap(a, 1, i);  // 将第一个数放到数组后面
        i--;
        heapify(a, 1, i);  // 堆化
    }
}

3. 能用堆解决的问题

堆的应用十分广泛,例如 Top K 这一系类的问题,都能用堆来解决。假如现在有 10 亿数据,要取其中最大的 10 个数据,如果我们对这 10 亿个数据都进行排序,肯定能得到结果,但是数据量太大,如果都进行排序就会非常耗 CPU,而且我们只需要其中的 10 个数据,对所有数据排序,显然有点太浪费了。如果用堆来解决,我们可以建立一个可以存放 10 个数据的「小顶堆」,在初始时,可以先一次放入 10 个数据,后面在遍历剩下的数据时,判断是不是比堆顶的元素大,如果大,就将现在的堆顶元素删除,然后将当前数据放入到堆中;如果小于或者等于,则不做任何操作,这样最终就能得到这 10 亿个数据中最大的 10 个数据了。

另外,定时任务也可以用堆来实现。每个任务会在指定的时间来执行,这个时候,可以将任务达到时间最小的任务放到小顶堆的堆顶,那么每次执行时,就取堆顶的任务执行即可。

堆还可以用来实现优先级队列。在优先级队列中,每次从队列中取出的元素肯定是优先级最低或者最高的元素,这恰好与堆中的小顶堆和大顶堆对应。在 Java 中提供了工具类 PriorityQueue 来实现优先级队列。

4. 总结

总结一下,堆是一棵完全二叉树,它适合采用数组来存储数据。大顶堆的堆顶元素是堆中最大的元素,小顶堆中的堆顶元素是堆中最小的元素。

采用堆这种数据结构,对数据进行排序时,不需要占用额外的存储空间,效率也很高,时间复杂度为 O(nlogn)。

在文中的例子中,在使用数组存储堆的数据时,将数组下标为 0 的位置,没有存储元素,这是为了方便计算左右子结点的位置。实际上,下标为 0 的位置也可以用来存放元素,不同的是,计算左右子结点的位置的公式变了。

堆的简单学习

标签:插入   结果   void   length   技术   private   count   index   总结   

原文地址:https://www.cnblogs.com/wangzheming35/p/13229498.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!