堆 (数据结构)

最新推荐文章于 2024-04-03 19:05:53 发布
最新推荐文章于 2024-04-03 19:05:53 发布
阅读量3.8k 收藏 3
点赞数 4
分类专栏： 算法 JAVA 文章标签： 堆 数据结构 算法 java API
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DERRANTCM/article/details/51503878
版权
JAVA 同时被 2 个专栏收录
14 篇文章 1 订阅
订阅专栏
算法
1 篇文章 1 订阅
订阅专栏

堆 (数据结构)[工程下载>>>]

　　堆（英语：Heap）是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。在队列中，调度程序反复提取队列中第一个作业并运行，因为实际情况中某些时间较短的任务将等待很长时间才能结束，或者某些不短小，但具有重要性的作业，同样应当具有优先权。堆即为解决此类问题设计的一种数据结构。

1.1 逻辑定义

　　n个元素序列 k1,k2...ki...kn ,当且仅当满足下列关系时称之为堆：

　　 (ki<=k2i,ki<=k2i+1)或者(ki>=k2i,ki>=k2i+1),(i=1,2,3,4,...,n/2)

1.2 性质

　　堆的实现通过构造二叉堆（binary heap），实为二叉树的一种；由于其应用的普遍性，当不加限定时，均指该数据结构的这种实现。这种数据结构具有以下性质。

任意节点小于（或大于）它的所有后裔，最小元（或最大元）在堆的根上（堆序性）。
堆总是一棵完全树。即除了最底层，其他层的节点都被元素填满，且最底层尽可能地从左到右填入。

　　将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。常见的堆有二叉堆、斐波那契堆等。

1.3 API介绍

　　堆数据结构，如果数数元素是可以比较的，就不需要传入比较器对象，如果数据是可以比较的就要传入比较器，根据传入的比较器，可以实现大顶堆和小顶堆。

方法名作用时间复杂度
Heap()无参构造函数-
Heap(T t)构造函数-
Heap(T t, Comparator< T > comparator)构造函数-
Heap(Comparator< T > comparator)构造函数-
Heap(Collection< T > coll)构造函数-
Heap(Collection< T > coll, Comparator< T > comparator)构造函数-
Comparator< T > getComparator()获取比较器对象-
setComparator(Comparator< T > comparator)设置比较器对象-
shiftUp(int idx)向上调整堆 O(log(n))
shiftDown(int idx)向下调整堆 O(log(n))
int compare(Object o1, Object o2)比较两个数的大小-
add(T item)添加一个元素 O(log(n))
add(T[] arr)添加一组元素 O(n∗log(n))
add(Collection< T > coll)添加一组元素 O(n∗log(n))
T getTop()获取堆顶元素，但不删除 O(1)
T deleteTop()删除堆顶结点 O(log(n))
int size()获取堆的大小 O(1)
boolean isEmpty()判断堆是否为空 O(1)
clear()清空堆，如果有比较器，不会删除比较器-
delete()删除元素，并且清空比较器对象-
List< T > getData()获取堆中所有的数据-
toString()堆信息描述-

1.4 代码实现

package com.datastruct;

import java.util.*;

/**
 * 堆数据结构，如果数数元素是可以比较的，就不需要传入比较器对象，如果数据是可以比较的就要传入比较器，
 * 根据传入的比较器，可以实现大顶堆和小顶堆。
 * Author: 王俊超
 * Time: 2016-05-25 19:30
 * CSDN: http://blog.csdn.net/derrantcm
 * Github: https://github.com/Wang-Jun-Chao
 * Declaration: All Rights Reserved !!!
 */
public class Heap<T> {
    // 堆中元素存放的集合
    private List<T> data;
    // 比较器
    private Comparator<T> comparator;

    /**
     * 无参构造函数
     */
    public Heap() {
        data = new ArrayList<>(64);
    }

    /**
     * 构造函数
     *
     * @param t 元素
     */
    public Heap(T t) {
        this();
        add(t);
    }

    /**
     * 构造函数
     *
     * @param t          元素对象
     * @param comparator 比较器对象
     */
    public Heap(T t, Comparator<T> comparator) {
        this.comparator = comparator;
        add(t);
    }

    /**
     * 构造函数
     *
     * @param comparator 比较器对象
     */
    public Heap(Comparator<T> comparator) {
        if (comparator == null) {
            throw new NullPointerException("比较器不能为空");
        }

        this.comparator = comparator;
        this.data = new ArrayList<>(64);
    }

    /**
     * 构造函数
     *
     * @param arr 数据数组
     */
    public Heap(T[] arr) {
        if (arr == null) {
            throw new NullPointerException("数据据为空");
        }

        this.data = new ArrayList<>(arr.length);
        this.add(arr);
    }

    /**
     * 构造函数
     *
     * @param arr        数据数组
     * @param comparator 比较器对象
     */
    public Heap(T[] arr, Comparator<T> comparator) {
        if (arr == null) {
            throw new NullPointerException("数据据为空");
        }

        if (comparator == null) {
            throw new NullPointerException("比较器为空");
        }

        this.comparator = comparator;
        this.data = new ArrayList<>(arr.length);
        add(arr);
    }

    /**
     * 构造函数
     *
     * @param coll 数据集合
     */
    public Heap(Collection<T> coll) {
        if (coll == null) {
            throw new NullPointerException("数据据为空");
        }

        this.data = new ArrayList<>(coll.size());
        add(coll);
    }


    /**
     * 构造函数
     *
     * @param coll       数据集合
     * @param comparator 比较器对象
     */
    public Heap(Collection<T> coll, Comparator<T> comparator) {
        if (coll == null) {
            throw new NullPointerException("数据据为空");
        }

        this.comparator = comparator;
        this.data = new ArrayList<>(coll.size());
        add(coll);
    }


    /**
     * 获取比较器对象
     *
     * @return 比较器对象
     */
    public Comparator<T> getComparator() {
        return comparator;
    }

    /**
     * 设置比较器对象
     *
     * @param comparator 比较器对象
     */
    public void setComparator(Comparator<T> comparator) {
        this.comparator = comparator;
    }

    /**
     * 向上调整堆
     *
     * @param idx 被上移元素的起始位置
     */
    public void shiftUp(int idx) {
        // 检查是位置是否正确
        if (idx < 0 || idx >= data.size()) {
            throw new IllegalArgumentException(idx + "");
        }

        // 获取开始调整的元素对象
        T intent = data.get(idx);

        // 如果不是根元素，则需要上移
        while (idx > 0) {
            // 找父元素对象的位置
            int parentIdx = (idx - 1) / 2;
            // 获取父元素对象
            T parent = data.get(parentIdx);
            //上移的条件，子节点比父节点大，此处定义的大是以比较器返回值为准
            if (compare(intent, parent) > 0) {
                // 将父节点向下放
                data.set(idx, parent);
                idx = parentIdx;
                // 记录父节点下放的位置
            }
            // 子节点不比父节点大，说明父子路径已经按从大到小排好顺序了，不需要调整了
            else {
                break;
            }
        }

        // index此时记录是的最后一个被下放的父节点的位置（也可能是自身），
        // 所以将最开始的调整的元素值放入index位置即可
        data.set(idx, intent);
    }

    /**
     * 向下调整堆
     *
     * @param idx 被下移的元素的起始位置
     */
    public void shiftDown(int idx) {
        // 检查是位置是否正确
        if (idx < 0 || idx >= data.size()) {
            throw new IllegalArgumentException(idx + "");
        }

        // 获取开始调整的元素对象
        T intent = data.get(idx);
        // 获取开始调整的元素对象的左子结点的元素位置
        int leftIdx = idx * 2 + 1;
        // 如果有左子结点
        while (leftIdx < data.size()) {
            // 取左子结点的元素对象，并且假定其为两个子结点中最大的
            T maxChild = data.get(leftIdx);
            // 两个子节点中最大节点元素的位置，假定开始时为左子结点的位置
            int maxIdx = leftIdx;

            // 获取右子结点的位置
            int rightIdx = leftIdx + 1;
            // 如果有右子结点
            if (rightIdx < data.size()) {
                T rightChild = data.get(rightIdx);
                // 找出两个子节点中的最大子结点
                if (compare(rightChild, maxChild) > 0) {
                    maxChild = rightChild;
                    maxIdx = rightIdx;
                }
            }

            // 如果最大子节点比父节点大，则需要向下调整
            if (compare(maxChild, intent) > 0) {
                // 将较大的子节点向上移
                data.set(idx, maxChild);
                // 记录上移节点的位置
                idx = maxIdx;
                // 找到上移节点的左子节点的位置
                leftIdx = 2 * idx + 1;
            }
            // 最大子节点不比父节点大，说明父子路径已经按从大到小排好顺序了，不需要调整了
            else {
                break;
            }

        }
        // index此时记录是的最后一个被上移的子节点的位置（也可能是自身），
        // 所以将最开始的调整的元素值放入index位置即可
        data.set(idx, intent);
    }

    /**
     * 比较两个数的大小
     *
     * @param o1 数一
     * @param o2 数二
     * @return 比较结果
     */
    private final int compare(Object o1, Object o2) {
        return comparator == null ? ((Comparable<? super T>) o1).compareTo((T) o2)
                : comparator.compare((T) o1, (T) o2);
    }

    /**
     * 添加一个元素
     *
     * @param item 添加的元素
     */
    public void add(T item) {
        // 将元素添加到最后
        data.add(item);
        // 上移，以完成重构
        shiftUp(data.size() - 1);
    }


    /**
     * 向堆中添加元素
     *
     * @param arr 元素数组
     */
    public void add(T[] arr) {
        if (arr != null) {
            for (T t : arr) {
                add(t);
            }
        }
    }

    /**
     * 向堆中添加元素
     *
     * @param coll 元素集合
     */
    public void add(Collection<T> coll) {
        if (coll != null) {
            for (T t : coll) {
                add(t);
            }
        }
    }

    /**
     * 获取堆顶元素，但不删除
     *
     * @return 堆顶元素
     */
    public T getTop() {
        // 如果堆已经为空，就抛出异常
        if (data.isEmpty()) {
            throw new NoSuchElementException("堆已经为空");
        }

        return data.get(0);
    }

    /**
     * 删除堆顶元素
     *
     * @return 堆顶结点
     */
    public T deleteTop() {
        // 如果堆已经为空，就抛出异常
        if (data.isEmpty()) {
            throw new NoSuchElementException("堆已经为空");
        }

        // 获取堆顶元素
        T first = data.get(0);
        // 删除最后一个元素
        T last = data.remove(data.size() - 1);

        // 删除元素后，如果堆为空的情况，说明删除的元素也是堆顶元素
        if (data.size() == 0) {
            return last;
        } else {
            // 将删除的元素放入堆顶
            data.set(0, last);
            // 自上向下调整堆
            shiftDown(0);
            // 返回堆顶元素
            return first;
        }
    }

    /**
     * 获取堆的大小
     *
     * @return 堆的大小
     */
    public int size() {
        return data.size();
    }

    /**
     * 判断堆是否为空
     *
     * @return 堆是否为空
     */
    public boolean isEmpty() {
        return data.isEmpty();
    }

    /**
     * 清空堆，如果有比较器，不会删除比较器
     */
    public void clear() {
        data.clear();
    }

    /**
     * 删除元素，并且清空比较器对象
     */
    public void delete() {
        data.clear();
        comparator = null;
    }

    /**
     * 获取堆中所有的数据
     *
     * @return 堆中所在的数据
     */
    public List<T> getData() {
        return data;
    }

    /**
     * 堆信息描述
     *
     * @return 堆信息描述字符串
     */
    @Override
    public String toString() {
        return data.toString();
    }
}

1.5 测试

package com.datastruct;

/**
 * Author: 王俊超
 * Time: 2016-05-25 20:45
 * CSDN: http://blog.csdn.net/derrantcm
 * Github: https://github.com/Wang-Jun-Chao
 * Declaration: All Rights Reserved !!!
 */
public class Node {
    private int val;

    public Node() {
    }

    public Node(int val) {
        this.val = val;
    }

    @Override
    public String toString() {
        return "" + val;
    }

    public int getVal() {
        return val;
    }

    public void setVal(int val) {
        this.val = val;
    }
}

package com.datastruct;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Random;

/**
 * Author: 王俊超
 * Time: 2016-05-25 20:44
 * CSDN: http://blog.csdn.net/derrantcm
 * Github: https://github.com/Wang-Jun-Chao
 * Declaration: All Rights Reserved !!!
 */
public class HeapTest {

    // 产生的随机数数的个数
    private final static int NUM = 20;
    // 下边界，包含
    private final static int LOWER = 0;
    // 上边界，不包含
    private final static int UPPER = 100;


    private static List<Integer> getNumber() {
        List<Integer> arr = new ArrayList<>(NUM);
        Random random = new Random();

        for (int i = 0; i < NUM; i++) {
            arr.add(LOWER + random.nextInt(UPPER - LOWER));
        }
        return arr;
    }

    private List<Node> getNodes() {
        List<Integer> arr = getNumber();
        List<Node> nodes = new ArrayList<>();

        for (Integer i : arr) {
            nodes.add(new Node(i));
        }
        return nodes;
    }

    @Test
    public void testMaxHeapWithoutComparator() {
        List<Integer> arr = getNumber();
        System.out.println("HeapTest.testMaxHeapWithoutComparator");
        System.out.println(arr);
        Heap<Integer> maxHeap = new Heap<>(arr);
        System.out.println(maxHeap);
    }

    @Test
    public void testMaxHeapWithComparator() {
        List<Integer> arr = getNumber();
        System.out.println("HeapTest.testMaxHeapWithComparator");
        System.out.println(arr);
        Heap<Integer> maxHeap = new Heap<>(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        System.out.println(maxHeap);
    }

    /**
     * 使用自定义类进行操作
     */
    @Test
    public void testMaxHeapWithComparator2() {
        List<Node> nodes = getNodes();

        System.out.println("HeapTest.testMaxHeapWithComparator2");
        System.out.println(nodes);
        Heap<Node> maxHeap = new Heap<>(nodes, new Comparator<Node>() {
            @Override
            public int compare(Node o1, Node o2) {
                return o1.getVal() - o2.getVal();
            }
        });
        System.out.println(maxHeap);
    }

    @Test
    public void testMinHeapWithComparator() {
        List<Integer> arr = getNumber();
        System.out.println("HeapTest.testMinHeapWithComparator");
        System.out.println(arr);
        Heap<Integer> maxHeap = new Heap<>(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println(maxHeap);
    }

    /**
     * 使用自定义类进行操作
     */
    @Test
    public void testMinHeapWithComparator2() {
        List<Node> nodes = getNodes();

        System.out.println("HeapTest.testMaxHeapWithComparator2");
        System.out.println(nodes);
        Heap<Node> maxHeap = new Heap<>(nodes, new Comparator<Node>() {
            @Override
            public int compare(Node o1, Node o2) {
                return o2.getVal() - o1.getVal();
            }
        });
        System.out.println(maxHeap);
    }
}

1.6 测试结果

这里写图片描述

Wang-Junchao
关注
专栏目录
非科班杀进字节，全靠GitHub最强的数据结构与算法笔记
javaAnPou的博客
03-23 201
这份学习资料里面的答案非常的严谨 并且题都标出了难度等级 大家可以一目了然。数据结构的学法，我推荐是直接看书，一边学习一边刷题，
堆排序以及堆数据结构的优势
qq_44703805的博客
10-24 2276
我们要了解堆排序，必须要知道堆这个伟大的数据结构。 堆是一个非常重要的数据结构，可以被看做一棵完全二叉树的数组对象。 我们的数据实际上在逻辑上可以根据数组的索引构建出为一颗完全二叉树，结点的位置与索引之间的关系是： i位置结点的左孩子在数组中的位置是：(2 * i) + 1，右孩子在数组中的位置是：(2*i)+2 i位置结点的父节点在数组中的位置是：(i-1) / 2。 堆的类型有两种： 1）大根堆：每个二叉树的中的根结点是最大的。 2）小根堆：每个二叉树的中的根结点是最小的。 堆有两个非常重要的方法：
GitHub 标星 3w+，很全面的算法和数据结构知识
程序员吴师兄的博客
07-08 1727
点击蓝色“五分钟学算法”关注我哟加个“星标”，一起学算法今天分享一个开源项目，里面汇总了程序员技术面试时需要了解的 算法和数据结构知识，并且还提供了相应的代码，目前 Gi...
【数据结构】我把数据结构相关代码上传到github了
haohulala的博客
07-21 325
传送门https://github.com/hao297531173/DataStructCode_c
数据结构
github_37002236的博客
08-24 274
数据结构 1.队列（非阻塞、阻塞）：https://www.cnblogs.com/lemon-flm/p/7877898.html 2.集合（set、hashSet[hascode-&gt;equal]、TreeSet、LinkedHashSet）： https://blog.csdn.net/qq_33642117/article/details/52040345 3.链表、数组（Li...
GitHub 上值得前端学习的数据结构与算法项目，web网站开发
最新发布
2401_83977825的博客
04-03 689
我一直觉得技术面试不是考试，考前背背题，发给你一张考卷，答完交卷等通知。首先，技术面试是一个 认识自己 的过程，知道自己和外面世界的差距。更重要的是，技术面试是一个双向了解的过程，要让对方发现你的闪光点，同时也要 试图去找到对方的闪光点，因为他以后可能就是你的同事或者领导，所以，面试官问你有什么问题的时候，不要说没有了，要去试图了解他的工作内容、了解这个团队的氛围。找工作无非就是看三点：和什么人、做什么事、给多少钱，要给这三者在自己的心里划分一个比例。
堆排序（Heap Sort）是一种基于二叉堆数据结构的排序算法
01-15
堆排序 堆排序（Heap Sort）是一种基于二叉堆数据结构的排序算法
go-heaps：Go中堆数据结构的参考实现-treap，skew，leftlist，pairing，fibonacci
02-05
Go中堆数据结构的参考实现 安装 $ go get -u github.com/theodesp/go-heaps 内容 堆 ：配对堆是一种堆数据结构，具有相对简单的实现和出色的实际摊销性能。 ：二进制堆的变体。 每个节点都有一个s值，即到最近叶子...
js-fibonacci-heap：JavaScript的斐波那契堆数据结构
02-12
Fibonacci用于JavaScript的堆数据结构。 参见 。 父母是 。 :warning: 该代码要求定义regeneratorRuntime ，例如，通过导入 。 let heap = new FibonacciHeap ( compare . increasing ) ; 参考
数据结构——堆
qq_49912778的博客
03-20 9769
1.堆的定义 堆（heap）是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵完全二叉树(逻辑层面上)的数组对象(物理层面上),常用来在一组变化频繁(发生增删查改的频率较高)的数据中寻找最值.将根结点最大的堆叫做最大堆或大根堆，这样可以找到堆中的最大值(根节点的值);根结点最小的堆叫做最小堆或小根堆,这样可以找到堆中的最小值。 2.堆在物理上和逻辑上的相互转换 3.堆的核心操作——向下调整 要实现向下调整,需要满足的前提是:针对某个结点...
2021-09-12 基本数据结构(github后续更新,不太会写文章,甚至连注释都写不好)
weixin_44323710的博客
09-12 220
c语言数据结构 这几天有点性质,写了几个简单的数据结构,说实话,不是很熟悉,写起来也不是特别快 就当是给两年前的自己讲课了,那时候学的数据结构,老师讲的很好,自己学的一塌糊涂,今天复习了一哈子,仅供参考 ps1:这里有一点小问题,hash表跑的速度比C++ 快了 几十倍,不知道是不是c++ 的哈希表来回申请释放内存导致的,就算我开了固定大小的内存ha.reserve(lang);,c++ 的速度提升了一倍,但依旧很慢,请大佬解惑 ps2:二叉树map,仅仅做了排序,没有进行平衡,那个难度太高了,自己想不出来
根本停不下来！GitHub顶级数据结构刷题教程，Star还在疯涨
guanshengg的博客
09-04 387
提起数据结构与算法，大家可能第一时间想到的就是蓝桥杯这种算法竞赛，并不会太过于在意它在面试中的占比。因为在若干年前，你去面试这种互联网公司或者大的IT公司，面试官并不会过于考察你的算法能力，甚至说你会简单的写一些框架，搭一些数据库，就能找到一份不错的工作但是直至今日，大家会发现面试的门槛越来越高，甚至来说去到一些大公司去面试算法与数据结构的题目已经成为必问了，算法的在面试的占比已经越来越高，为了帮助小伙伴们更好的学习数据结构与算法，我找来了这份GitHub定级数据机构刷题教程，希望能够帮助到大家。
字节内部专用数据结构与算法笔记，GitHub已标星74K+
stone_tmp的博客
06-20 149
数据结构和算法是相辅相成的。数据结构是为算法服务的，算法作用在特定的数据结构之上。因此，我们无法孤立数据结构来讲算法，也无法孤立算法来讲数据结构。数据结构是静态的，它只是组织数据的一种方式。如果不在它的基础上操作、构建算法，孤立存在的数据结构就是没用的。
字节跳动内部专用数据结构与算法笔记，在GitHub发现时标星已74K+
代码界的扛把子
07-27 112
什么是数据结构和算法数据结构和算法是相辅相成的。数据结构是为算法服务的，算法作用在特定的数据结构之上。因此，我们无法孤立数据结构来讲算法，也无法孤立算法来讲数据结构。数据结构是静态的，它只是组织数据的一种方式。如果不在它的基础上操作、构建算法，孤立存在的数据结构就是没用的。数据结构的作用在许多程序设计当中，数据结构的选择是一个基本的设计考虑因素，系统的实现的困难程度和系统构造的质量都严重依赖于是否选择了最优的数据结构。能够有效地提高运行的效率和节约存储空间的使用。很多人都会问，数据结构重要吗？
脉脉转发3W次的字节内部首发“数据结构算法”手册！惨大厂被封杀
weixin_47083537的博客
08-21 575
数据结构对于计算机、应用数学及各类工程领域具有非常重要的作用。然而初学者在刚接触数据结构时往往会忽视其重要性，认为还不如学个C或者Java来得直接一点。 但是，算法与数据结构是程序设计中相辅相成的两个方面，是计算机学科的重要基石。 著名计算机科学家尼古拉斯·沃斯（Niklaus Wirth）有一句在计算机领域人尽皆知的名言“算法+数据结构=程序”（Algorithm+Data Structures=Programs）。 数据结构，是抽象地表示数据的方式；算法，则是计算的一系列有效、通用的步骤。那么，如何打.
数据结构——【堆】
m0_69323023的博客
09-12 6401
堆
带你认识数据结构中的堆，并实现一个堆
qq_45691220的博客
05-05 304
文章目录一，二叉树的顺序存储(实现堆的必备知识)1.存储方式2.下标关系（自己可以借助数组进行推导）二，堆1.概念2.向下调整3.向上调整4.建堆 一，二叉树的顺序存储(实现堆的必备知识) 1.存储方式 使用数组保存二叉树结构，方式即将二叉树用层序遍历方式放入数组中。 一般只适合表示完全二叉树，因为非完全二叉树会有空间的浪费。 这种方式的主要用法就是堆的表示 2.下标关系（自己可以借助数组进行推...
数据结构--堆
qq_turn
06-12 2692
第十一章 22题 // An highlighted block var foo = 'bar';
什么是堆？（堆的介绍）
化身孤岛的鲸o的博客
01-07 3484
一、定义 堆（英语：heap)是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。堆总是满足下列性质： （1）堆中某个节点的值总是不大于或不小于其父节点的值； （2）堆总是一棵完全二叉树。 将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。常见的堆有二叉堆、斐波那契堆等。 堆是非线性数据结构，相当于一维数组，有两个直接后继。 堆的定义如下：n个元素的...
哈希表查找算法与堆数据结构解析
描述中提到了堆的概念，堆是一种特殊的数据结构，它可以被看作是一棵完全二叉树的顺序存储。堆分为最小堆和最大堆： - 最小堆：在最小堆中，每个父节点的值都小于或等于其子节点的值，堆顶的元素（即数组的第一个...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值