数据结构之堆

最新推荐文章于 2019-01-09 15:36:10 发布
最新推荐文章于 2019-01-09 15:36:10 发布
阅读量353 收藏
点赞数
分类专栏： 数据结构 文章标签： 最大堆 最小堆
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq2430/article/details/85219611
版权

简介

堆是一颗完全二叉树，分为两种，最大堆和最小堆，两者的区别在于排序方式上。最大（小）堆是值在一颗完全二叉树中，根节点的值不小于（不大于）树中其他节点的值。这里要注意的是，堆中的任一子树也是堆，但不要求一颗子树中的父节点的值不小于（不大于）另一颗子树中节点值。

在这里插入图片描述

最大堆

在本小节中，我们创建一个最大堆，包含建堆、增加、删除、替换4中操作。最小堆与最大堆类似，本节不再讲述最小堆。在文章最后会附上最小堆的代码实现。

建堆

在这里，我们采用数组来实现完全二叉树，并提供一个构造函数，可以将一个数组转换为最大堆。

我们先看下如何用一颗存储一颗完全二叉树。从下面的数组表示可以看出，如果父节点的索引为n，那么左子节点的索引值为2n+1，右子节点的索引值为2n+2。如果子节点的索引值为x，那么父节点的索引值为x/2。不懂的话，建议去看下树的层序遍历。
在这里插入图片描述

基本定义

public class MaxHeap<E extends Comparable<E>> {

	//使用数组来存储数据
    private E[] data;
    
	//堆中元素的个数
    private int size;

	//堆的容量
    private int capacity;

    public MaxHeap(int capacity) {
        this.capacity = capacity;
        this.data = (E[]) new Object[capacity];
        this.size = 0;
    }

    public MaxHeap(E[] elements) {
        //将一个数组构成最大堆
        if (elements == null || elements.length == 0) {
            throw new IllegalArgumentException("elements is empty.");
        }
        this.capacity = elements.length;
        this.size = elements.length;
        this.data = Arrays.copyOf(elements, size);
        //heapify:从非叶子节点不断的执行shift down操作
        for (int i = data.length - 1; i >= 0; i--) {
            shiftDown(getParent(i));
        }
    }
    
    private int getParent(int child) {
        //以数组下标0开始存储元素，父亲节点的下标是(child - 1) / 2
        //以数组下标1开始存储元素，父亲节点的下标是child / 2
        return (child - 1) / 2;
  	}
	
	 private int getLeftChild(int parent) {
        //以数组下标0开始存储元素，左孩子节点的下标是2 * parent + 1
        //以数组下标1开始存储元素，左孩子节点的下标是2 * parent
        return 2 * parent + 1;
    }
}

shiftDown

在上面的构造函数的代码中，提到shiftDown（下沉）操作。所谓的shiftDown操作就是不断的同子节点进行比较交互，最后找到元素位置的操作。如下图所示，不断对值为6的节点进行shiftDown操作，直到节点满足最大堆的性质（不小于左右子节点的值）。

在这里插入图片描述

因此，在上述的构造函数中，只要循环对树中的非叶子节点进行shiftDown操作，就可以完成建堆。

    private void shiftDown(int index) {
        int leftChildIdx = getLeftChild(index);
        //不必判断有右子节点是否存在，因为完全二叉树若左子节点不存在，右子节点就一定不存在，一定是叶子节点
        if (index != leftChildIdx && leftChildIdx < size) {
            //如果有左右子节点，则选择值最大的节点进行比较
            int maxIndex = leftChildIdx + 1 < size && data[leftChildIdx + 1].compareTo(data[leftChildIdx]) > 0
                    ? leftChildIdx + 1 : leftChildIdx;
            if (data[index].compareTo(data[maxIndex]) < 0) {
                swap(index, maxIndex);
                shiftDown(maxIndex);
            }
        }
    }

删除

在堆中，只允许删除根节点的元素。因为在最大（小）堆中，删除的值是堆中最大（小）值。

删除操作，只要将堆中的根节点和最后一个节点交换位置，再将最后一个节点指向null。将根节点不断的执行shiftDown操作即可。如下图所示，我们删除一个值为10的根节点。

在这里插入图片描述

  public E remove() {
        if (isEmpty()) {
            return null;
        }
        E maxValue = data[0];
        //将第一元素与最后一个交换位置，然后不断的将跟节点执行shift down操作
        swap(0, --size);
        data[size] = null;
        shiftDown(0);
        return maxValue;
    }

添加

当我们向堆中添加节点后，要求新堆也要满足最大堆的性质（节点值不大于父节点值），也就是说，新添加的节点在整个堆中的位置是固定的。我们可以将新节点添加到堆的最后，然后不断的通过shiftUp（上浮）操作，来交换父子节点。

在这里插入图片描述

    public void add(E e) {
        if (e == null) {
            throw new IllegalArgumentException("element is null..");
        }
        if (size + 1 == capacity) {
            throw new ArrayIndexOutOfBoundsException("add error. array is full.");
        }
        //添加到元素末尾
        data[size++] = e;
        //将元素添加到堆的最后一个元素，不断的将最后一个节点执行shift up操作
        shiftUp(size - 1);
    }
    
    private void shiftUp(int index) {
        int parent = getParent(index);
        if (index != parent && data[parent].compareTo(data[index]) < 0) {
            //子节点比父节点大，交换元素位置
            swap(index, parent);
            //交换元素后，再次与父节点进行比较，直到比父节点的值小
            shiftUp(parent);
        }
    }

替换

替换元素比较简单，这里不在过多描述了，代码如下。

    public E replace(E e) {
        E old = data[0];
        data[0] = e;
        shiftDown(0);
        return old;
    }

实现

最小堆

public class MaxHeap<E extends Comparable<E>> {

    //使用数组来存储数据
    private E[] data;

    //堆中元素的个数
    private int size;

    //堆的容量
    private int capacity;

    public MaxHeap(int capacity) {
        this.capacity = capacity;
        this.data = (E[]) new Object[capacity];
        this.size = 0;
    }

    public MaxHeap(E[] elements) {
        //将一个数组构成最大堆
        if (elements == null || elements.length == 0) {
            throw new IllegalArgumentException("elements is empty.");
        }
        this.capacity = elements.length;
        this.size = elements.length;
        this.data = Arrays.copyOf(elements, size);
        //heapify:从非叶子节点不断的执行shift down操作
        for (int i = data.length - 1; i >= 0; i--) {
            shiftDown(getParent(i));
        }
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public int getSize() {
        return size;
    }

    public E remove() {
        if (isEmpty()) {
            return null;
        }
        E maxValue = data[0];
        //将第一元素与最后一个交换位置，然后不断的将跟节点执行shift down操作
        swap(0, --size);
        data[size] = null;
        shiftDown(0);
        return maxValue;
    }


    public void add(E e) {
        if (e == null) {
            throw new IllegalArgumentException("element is null..");
        }
        if (size + 1 == capacity) {
            throw new ArrayIndexOutOfBoundsException("add error. array is full.");
        }
        //添加到元素末尾
        data[size++] = e;
        //将元素添加到堆的最后一个元素，不断的将最后一个节点执行shift up操作
        shiftUp(size - 1);
    }

    public E replace(E e) {
        E old = data[0];
        data[0] = e;
        shiftDown(0);
        return old;
    }

    private void shiftDown(int index) {
        int leftChildIdx = getLeftChild(index);
        //不必判断有右子节点是否存在，因为完全二叉树若左子节点不存在，右子节点就一定不存在，一定是叶子节点
        if (index != leftChildIdx && leftChildIdx < size) {
            //如果有左右子节点，则选择值最大的节点进行比较
            int maxIndex = leftChildIdx + 1 < size && data[leftChildIdx + 1].compareTo(data[leftChildIdx]) > 0
                    ? leftChildIdx + 1 : leftChildIdx;
            if (data[index].compareTo(data[maxIndex]) < 0) {
                swap(index, maxIndex);
                shiftDown(maxIndex);
            }
        }
    }


    private void shiftUp(int index) {
        int parent = getParent(index);
        if (index != parent && data[parent].compareTo(data[index]) < 0) {
            //子节点比父节点大，交换元素位置
            swap(index, parent);
            //交换元素后，再次与父节点进行比较，直到比父节点的值小
            shiftUp(parent);
        }
    }


    private int getParent(int child) {
        //以数组下标0开始存储元素，父亲节点的下标是(child - 1) / 2
        //以数组下标1开始存储元素，父亲节点的下标是child / 2
        return (child - 1) / 2;
    }

    private int getLeftChild(int parent) {
        //以数组下标0开始存储元素，左孩子节点的下标是2 * parent + 1
        //以数组下标1开始存储元素，左孩子节点的下标是2 * parent
        return 2 * parent + 1;
    }

    private void swap(int a, int b) {
        E temp = data[a];
        data[a] = data[b];
        data[b] = temp;
    }
}

最小堆

public class MinHeap<E extends Comparable<E>> {

    //使用数组来存储数据
    private E[] data;

    //堆中元素的个数
    private int size;

    //堆的容量
    private int capacity;

    public MinHeap(int capacity) {
        this.capacity = capacity;
        this.data = (E[]) new Object[capacity];
        this.size = 0;
    }

    public MinHeap(E[] elements) {
        //将一个数组构成最大堆
        if (elements == null || elements.length == 0) {
            throw new IllegalArgumentException("elements is empty.");
        }
        this.capacity = elements.length;
        this.size = elements.length;
        this.data = Arrays.copyOf(elements, size);
        //heapify:从非叶子节点不断的执行shift down操作
        for (int i = data.length - 1; i >= 0; i--) {
            shiftDown(getParent(i));
        }
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public int getSize() {
        return size;
    }

    public E remove() {
        if (isEmpty()) {
            return null;
        }
        E minValue = data[0];
        //将第一元素与最后一个交换位置，然后不断的将跟节点执行shift down操作
        swap(0, --size);
        data[size] = null;
        shiftDown(0);
        return minValue;
    }


    public void add(E e) {
        if (e == null) {
            throw new IllegalArgumentException("element is null.");
        }
        if (size + 1 == capacity) {
            throw new ArrayIndexOutOfBoundsException("add error. array is full.");
        }
        //添加到元素末尾
        data[size++] = e;
        //将元素添加到堆的最后一个元素，不断的将最后一个节点执行shift up操作
        shiftUp(size - 1);
    }

    public E replace(E e) {
        E old = data[0];
        data[0] = e;
        shiftDown(0);
        return old;
    }

    private void shiftDown(int index) {
        int leftChildIdx = getLeftChild(index);
        //非叶子节点
        if (index != leftChildIdx && leftChildIdx < size) {
            //如果有左右子节点，则选择值最小的节点进行比较
            int minIndex = leftChildIdx + 1 < size && data[leftChildIdx + 1].compareTo(data[leftChildIdx]) < 0
                    ? leftChildIdx + 1 : leftChildIdx;
            if (data[index].compareTo(data[minIndex]) > 0) {
                swap(index, minIndex);
                shiftDown(minIndex);
            }
        }
    }


    private void shiftUp(int index) {
        int parent = getParent(index);
        if (index != parent && data[parent].compareTo(data[index]) > 0) {
            //子节点比父节点大，交换元素位置
            swap(index, parent);
            //交换元素后，再次与父节点进行比较，直到比父节点的值小
            shiftUp(parent);
        }
    }


    private int getParent(int child) {
        //以数组下标0开始存储元素，父亲节点的下标是(child - 1) / 2
        //以数组下标1开始存储元素，父亲节点的下标是child / 2
        return (child - 1) / 2;
    }

    private int getLeftChild(int parent) {
        //以数组下标0开始存储元素，左孩子节点的下标是2 * parent + 1
        //以数组下标1开始存储元素，左孩子节点的下标是2 * parent
        return 2 * parent + 1;
    }

    private void swap(int a, int b) {
        E temp = data[a];
        data[a] = data[b];
        data[b] = temp;
    }
}
shuaiZh
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之堆1
08-03
【数据结构之堆1】是关于数据结构中堆的详细解析，主要涵盖了堆的概念、分类、常见操作以及在LeetCode等刷题平台上的应用。堆作为一种特殊的完全二叉树，通常用于实现优先队列，以高效地进行最大值或最小值的查找、...
排序法-堆排序
lonely12a3a的博客
09-09 165
要理解堆排序需要理解一下概念： 二叉树：树中每个节点至多有两个子节点 二叉搜索树：对于树中任何节点，如果其左子节点不为空，那么该节点的value值永远 &gt;= 其左子节点；如果其右子节点不为空，那么该节点的value值永远 &lt;= 其右子节点 满二叉树：树中除了叶子节点，每个节点都有两个子节点 完全二叉树：在满足满二叉树的性质后，最后一层的叶子节点均需在最左边 完美二叉树：满足完...
堆和树的区别
大学之道
08-05 8721
以小根堆为例，堆的特点是双亲结点的关键字必然小于等于孩子结点的关键字，而两个孩子结点的关键字没有次序规定 而二叉排序树中，每个双亲结点的关键字均大于左子树结点的关键字，均小于右子树j结点的关键字，也就是说，每个双亲结点的左右孩子的关键字有次序关系 这...
堆树（最大堆、最小堆）详解
热门推荐
渴望，就奋力追寻...
03-16 6万+
一、堆树的定义 堆树的定义如下： （1）堆树是一颗完全二叉树； （2）堆树中某个节点的值总是不大于或不小于其孩子节点的值； （3）堆树中每个节点的子树都是堆树。 当父节点的键值总是大于或等于任何一个子节点的键值时为最大堆。 当父节点的键值总是小于或等于任何一个子节点的键值时为最小堆。如下图所示，左边为最大堆，右边为最小堆。 二、堆树的操作 以最大堆为例进行讲解
数据结构 堆树（最大堆、最小堆）
Markus
01-09 5032
一、堆树的定义 （1）堆树是一颗完全二叉树； （2）堆树中某个节点的值总是不大于或不小于其孩子节点的值； （3）堆树中每个节点的子树都是堆树。 当父节点的键值总是大于或等于任何一个子节点的键值时为最大堆，也称大根堆。 当父节点的键值总是小于或等于任何一个子节点的键值时为最小堆，也称小根堆。 如下图所示，上边为最大堆，下边为最小堆。 二、堆树的操作 下面以最大堆为例进行讲解，最小堆同理。 2.1...
数据结构之堆详解
09-04
堆，作为一种特殊的数据结构，是实现优先队列的典型数据结构。它通常表现为一棵完全二叉树，且具有以下特性：对于大顶堆，每个父节点的值都大于或等于其子节点的值；对于小顶堆，父节点的值小于或等于子节点的值。...
C语言数据结构之堆排序源代码
12-25
本文实例为大家分享了C语言堆排序源代码，供大家参考，具体内容如下 1. 堆排序 堆排序的定义及思想可以参考百度百科： 用一句概括，堆排序就是一种改进的选择排序，改进的地方在于，每次做选择的时候，不单单把最大...
数据结构 堆
08-17
堆的实现，能够进行插入建堆，插入，删除，判空等操作
数据结构之队列
Shuai.Zhang
07-17 2万+
队列简介 队列简单来说就是一种允许再一段进行插入，再另一端进行删除操作的线性表，就像排队取票一样。插入的一段我们称之为队尾，删除的一端我们称之为队首。队列具有FIFO（先进先出）的特性。队列的结构图如下所示。 队列的简单实现 使用上一篇文章的动态数组实现了队列，代码非常简单，不多讲了。 public class ArrayQueue { private Array&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;E&
数据结构之二叉搜索树
Shuai.Zhang
08-26 2220
在前面的几章中，介绍了几种线性数据结构，主要包含数组、栈、队列、链表等。从本节开始，给大家介绍树这种数据结构。 在数据结构中，包括很多的树结构，像二叉树、二叉搜索树、线段树、字典树、红黑树等。本小节介绍的是二叉树和二叉搜索树，其余的树结构，会在后面的文章中再进行介绍。 树 在介绍二叉树之前，我们先准备些预备知识。 首先来看先什么是树。一颗树可以看做是由根节点（root）和以及0个或多个...
数据结构之数组
Shuai.Zhang
07-12 2115
数组简介 首先我们来简单的了解下什么是数组，数组是在内存中开辟出一段连续的空间用来存储数据，如下图所示。 既然是用来存储数据，就涉及到寻址问题，我们来看下数组是如何寻址的。因为是一段连续的空间，那么只要知道首地址和数组下标就可以计算出要查询数组元素的内存地址。比如说数组的首地址0x0001，数组中每个元素占4个字节，那么下标为1的地址为0x0005。 也就是因为这个原因，在数组中查询元素...
数据结构之链表
Shuai.Zhang
07-25 364
在前面的博客中，我们知道了数组这种数据结构的随机访问能力强，但是因为创建数组后，数组的容量时固定的。过大，容易造成空间浪费，过小，又不能满足存储需要。 本篇文章给大家介绍另一种线性数据结构——链表。 链表与数组不同，链表在物理存储上是非连续的。链表中的节点可以分为两部分，一个是存储的元素值，另一部分是指向下一个节点的指针。 单链表 单链表中的每个节点分为两个部分，一个是存储的数据值，另...
数据结构之Trie
Shuai.Zhang
12-01 303
简介 Trie，又称前缀树或字典树，是一种有序树，用于保存关联数组，其中的键通常是字符串。与二叉查找树不同，键不是直接保存在节点中，而是由节点在树中的位置决定。一个节点的所有子孙都有相同的前缀，也就是这个节点对应的字符串，而根节点对应空字符串。一般情况下，不是所有的节点都有对应的值，只有叶子节点和部分内部节点所对应的键才有相关的值。——摘自维基百科 基本性质 简单来说Trie是利用字符串的公共前...
数据结构之AVL树
Shuai.Zhang
11-25 196
在上一篇博客中，向大家介绍了二叉搜索树这一种数据结构。下面，我们来看一个问题。假设现在有一棵空树，我们先向树中添加一个根节点5，然后再添加6，然后再按顺序添加7、8。我们来看下生成的二叉搜索树是什么样子。 从上面的图中我们可以看出，二叉搜索树退化成了链表，大大的降低了查询效率。为了解决这个问题，我们引入一种新的数据结构——AVL树。 概述 AVL树是一种带有平衡条件的二叉搜索树。它的左右子树的高...
数据结构之栈
Shuai.Zhang
07-17 196
栈的简介 栈简单来说就是一种只允许在一端进行插入和删除操作的线性表，这一端我们通常称作栈顶，而另一端称作栈底。插入和删除也被称为入栈和出栈。因为栈只允许在一端进行操作，所以它具有FILO（先进后出）的特性，栈的结构图如下所示。 栈的简单实现 使用上一篇文章的动态数组实现了栈，代码非常简单，不多讲了。 public class ArrayStack&amp;amp;lt;E&amp;amp;gt;{ pr...
数据结构之线段树
Shuai.Zhang
12-16 169
简介 线段树是一种二叉查找树，它将一个区间划分为1个个单元，树的每个节点都是1个单元。如下图的树就是一颗区间树。 性质 对于线段树中的每一个非叶子节点[a, b]，它的左节点为[a, (a+b)/2]，右节点为[(a+b)/2+1, b]。 线段数是平衡二叉树，子节点的个数等于整个区间的长度。 实现 建树 在这里，我们使用数组来实现简单的线段树，树的结构如下。 public class Se...
物联网工程_基于RFID的食堂食品安全监测系统设计.docx
07-20
物联网工程_基于RFID的食堂食品安全监测系统设计
VisualSVN-VS2022
最新发布
07-20
VisualSVN-VS2022-8.0.5.vsix SVNVS插件，使用VS自带更新速度太慢，可下载后直接安装即可
深入探讨数据结构之堆：更多不只是堆排序，了解堆属性和应用。
数据结构中的堆是一种特殊的数据结构，常用于实现优先队列和堆排序等算法。堆是一个完全二叉树，可以使用数组来实现，并且根据堆属性来排序节点的顺序。堆可以分为大顶堆和小顶堆，也称为最大堆和最小堆。在大顶堆中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值