数据结构：树形结构之堆

最新推荐文章于 2024-05-09 18:22:20 发布
最新推荐文章于 2024-05-09 18:22:20 发布
阅读量461 收藏
点赞数 2
分类专栏： 数据结构与算法 文章标签： 数据结构 java 算法 树堆
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42080839/article/details/104280666
版权 
欲望以提升热忱，毅力以磨平高山。

什么是堆？

堆（heap)是计算机科学中一类特殊的数据结构的统称。堆通常是一个可被看做一棵树的数组对象。这里介绍的是最为常见的二叉堆。

二叉堆（Binary Heap）是一种特殊的堆，二叉堆是完全二元树并且总是满足下列性质：

  • 堆中某个节点的值总是不大于或不小于其父节点的值；
  • 堆总是一棵完全二叉树。

二叉堆有两种：最大堆和最小堆。

  • 最大堆：父结点的键值总是大于或等于任何一个子节点的键值；
  • 最小堆：父结点的键值总是小于或等于任何一个子节点的键值。

最大堆

二叉堆的数组表示法

如果对于一个二叉堆从上到下、从左至右依次从1开始编号，并将每个节点的编号作为数组的下标，那么就能得到一个用数组表示的二叉堆。采用数组表示法有以下优点：

  • 存储密度高
  • 能够轻易获得某个节点的双亲和左右孩子结点

根据二叉树的性质：下标为 i（i>1）处节点的双亲节点下标为 i/2（整除），下标为 i 处节点的做孩子节点下标为 2 * i ；右孩子节点下标为 2 * i + 1。
在这里插入图片描述
为了充分利用数组空间，我们可以从 0 开始编号，那么下标为 i（i>0）处节点的双亲节点下标为 ( i - 1 ) / 2（整除），下标为 i 处节点的做孩子节点下标为 2 * i + 1 ；右孩子节点下标为 2 * i + 2。
在这里插入图片描述

大顶堆实现

基于以前实现的动态数组，这里直接复用SeqList实现大顶堆
数据结构：线性数据结构

大顶堆的向上调整siftUp和向下调整siftDown
siftUp

向大顶堆中添加元素时，由于我们是基于数组实现的，因此可直接在数组末尾添加该元素。但是添加完元素后的堆并不一定满足大顶堆的性质，因此还需要进行大顶堆的调整（siftUp）。
下面展示了添加元素的过程：
在这里插入图片描述
在这里插入图片描述
在数组尾部添加52
在这里插入图片描述
向上调整，52 大于 16
在这里插入图片描述
向上调整，52 大于 41
在这里插入图片描述
52小于62 因此不需要再调整，此时就满足大顶堆的性质了。

向大顶堆中添加元素：

 
//从index处向上调整
    private void siftUp(int index) {

        //index > 0 并且 index处的值大于双亲的值 则进行向上调整为大顶堆
        while (index > 0 && data.getIndexOf(index).compareTo(data.getIndexOf(parent(index))) > 0) {

            data.swap(index, parent(index));
            index = parent(index);
        }
    }

    //向大顶堆中添加元素
    public void add(E e){
        data.addLast(e);
        siftUp(data.getSize() - 1);
    }

由于需要交换数组中的值，因此在SeqList中添加swap方法：

//交换下标为 i 和 j 下标的值
    public void swap(int i, int j) {
    
        if (i < 0 || i >= size) {
            throw new IllegalArgumentException(" index is illegal !");
        }
        if (j < 0 || j >= size) {
            throw new IllegalArgumentException(" index is illegal !");
        }
        T temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }
siftDown

需要取出大顶堆的最大元素时，我们可以将数组中最后一个元素放到堆顶，然后进行堆的向下调整。下面展示了取出大顶堆的最大元素的过程：
![在这里插入图片描述](https://img-blog.csdnimg.cn/20200212230457965.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgwODM5,size_16,color_FFFFFF,t_70
在这里插入图片描述
将数组最后一个元素放到堆顶。
在这里插入图片描述
如果待调整的元素小于它的孩子节点中的最大元素，那么就和最大元素交换。
16 小于 52 ，因此 16 和 52 发生了交换。
在这里插入图片描述
16 小于41 所以交换。
在这里插入图片描述
16 大于 15 因此不用再向下调整了，此时的堆满足大顶堆的性质。

取出最大元素

//从index处向下调整大顶堆
    private void siftDown(int index) {

        while (index * 2 + 1 < data.getSize()) {

            int maxIndex = leftChild(index);

            if (maxIndex + 1 < data.getSize() && data.getIndexOf(rightChild(index)).compareTo(data.getIndexOf(leftChild(index))) > 0) {
                maxIndex = rightChild(index);
            }//此时maxIndex为孩子元素中最大的元素

            //若index处的元素小于maIndex的元素则交换 否则结束
            if (data.getIndexOf(index).compareTo(data.getIndexOf(maxIndex)) < 0) {
                data.swap(index, maxIndex);
                index = maxIndex;
            }else {
                break;
            }
        }
    }

    //取出最大元素
    public E extractMax() {

        E ret = getMax();
        //将最后一个元素放到堆顶 向下调整大顶堆
        data.set(0, data.removeLast());
        siftDown(0);

        return ret;
    }
    
 //取出最大元素，并用e替换
    public E replace(E e){

        E ret = getMax();
        data.set(0, e);
        siftDown(0);

        return ret;
    }
将数组转化为大顶堆Heapify

将数组转化为大顶堆可以在遍历数组的时候调用上面的add方法，但是如果在原来数组上进行调整可以减少近半的次数，因为我们可以从第一个非叶子结点开始向下调整。

  //构造方法：Heapify 将一个数组转化为大顶堆
    public MaxBinaryHeap(E[] arr) {

        data = new SeqList<E>(arr);
        //从第一个非叶子结点开始，依次向下调整大顶堆
        for (int i = parent(arr.length - 1); i >=0 ; i--) {
            siftDown(i);
        }
    }

同时由于我们底层是用的自己实现的SeqList，因此还需在SeqList添加构造方法：

//将数组转化为动态数组
public SeqList(T[] arr) {

        data = (T[]) new Object[arr.length];
        for (int i = 0; i < arr.length; i++) {
            data[i] = arr[i];
        }
        size = arr.length;
    }
完整代码

到此，二叉大顶堆基本就实现了，需要注意的是，在实现大顶堆的相关操作时，对以前实现的SeqList增添了一个swap方法和一个构造方法。

MaxBinaryHeap

package cn.boom.heap;

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

    private SeqList<E> data;

    public MaxBinaryHeap(int capacity) {
        this.data = new SeqList<E>(capacity);
    }

    public MaxBinaryHeap() {
        this.data = new SeqList<E>();
    }

    //Heapify 将一个数组转化为大顶堆
    public MaxBinaryHeap(E[] arr) {

        data = new SeqList<E>(arr);

        //从第一个非叶子结点开始，依次向下调整大顶堆
        for (int i = parent(arr.length - 1); i >=0 ; i--) {
            siftDown(i);
        }
    }

    //获取元素个数
    public int getSize() {
        return data.getSize();
    }

    //非空判断
    public boolean isEmpty() {
        return data.isEmpty();
    }

    //获取参数下标对应的双亲下标
    private int parent(int index) {

        if (index < 0 || index >= data.getSize()) {
            throw new IllegalArgumentException("index = " + index + " , index is illegal !");
        }

        if (index == 0) {
            throw new IllegalArgumentException(" index = 0 , no parent !");
        }

        return ( index - 1 ) / 2;
    }

    //获取参数下标对应的左孩子下标
    private int leftChild(int index) {

        if (index < 0 || index >= data.getSize()) {
            throw new IllegalArgumentException("index = " + index + " , index is illegal !");
        }

        if ( 2 * index + 1 >= data.getSize()  ) {
            throw new IllegalArgumentException(" index = " + index +" , no leftChild !");
        }

        return 2 * index + 1;
    }

    //获取参数下标对应的右孩子下标
    private int rightChild(int index) {

        if (index < 0 || index >= data.getSize()) {
            throw new IllegalArgumentException("index = " + index + " , index is illegal !");
        }

        if ( 2 * index + 2 >= data.getSize()  ) {
            throw new IllegalArgumentException(" index = " + index +" , no rightChild !");
        }

        return 2 * index + 2;
    }

    //从index处向上调整
    private void siftUp(int index) {

        //index > 0 并且 index处的值大于双亲的值 则进行向上调整为大顶堆
        while (index > 0 && data.getIndexOf(index).compareTo(data.getIndexOf(parent(index))) > 0) {

            data.swap(index, parent(index));
            index = parent(index);
        }
    }

    //向大顶堆中添加元素
    public void add(E e){
        data.addLast(e);
        siftUp(data.getSize() - 1);
    }

    //获取最大元素
    public E getMax() {

        if (data.getSize() == 0) {
            throw new IllegalArgumentException("No data , No MaxValue ! ");
        }

        return data.getIndexOf(0);
    }

    //从index处向下调整大顶堆
    private void siftDown(int index) {

        while (index * 2 + 1 < data.getSize()) {

            int maxIndex = leftChild(index);

            if (maxIndex + 1 < data.getSize() && data.getIndexOf(rightChild(index)).compareTo(data.getIndexOf(leftChild(index))) > 0) {
                maxIndex = rightChild(index);
            }//此时maxIndex为孩子元素中最大的元素

            //若index处的元素小于maIndex的元素则交换 否则结束
            if (data.getIndexOf(index).compareTo(data.getIndexOf(maxIndex)) < 0) {
                data.swap(index, maxIndex);
                index = maxIndex;
            }else {
                break;
            }
        }
    }

    //取出最大元素
    public E extractMax() {

        E ret = getMax();

        //将最后一个元素放到堆顶 向下调整大顶堆
        data.set(0, data.removeLast());
        siftDown(0);

        return ret;
    }

    //取出最大元素，并用e替换
    public E replace(E e){

        E ret = getMax();

        data.set(0, e);
        siftDown(0);

        return ret;
    }

    @Override
    public String toString() {
        return "MaxBinaryHeap{" +
                "data=" + data +
                '}';
    }
}

修改后的SeqList

package cn.boom.heap;


public class SeqList<T> {

    private T[] data;
    private int size;

    //无参构造
    public SeqList(){
        data = (T[]) new Object[10];
        size = 0;
    }

    //带参构造 ：参数 容量
    public SeqList(int capacity) {
        data = (T[]) new Object[capacity];
        size = 0;
    }


    public SeqList(T[] arr) {

        data = (T[]) new Object[arr.length];

        for (int i = 0; i < arr.length; i++) {
            data[i] = arr[i];
        }

        size = arr.length;
    }

    /**
     * 获取真实长度（数据个数）
     * @return size
     */
    public int getSize(){
        return this.size;
    }

    /**
     * 获取index索引位置的元素
     * @param index
     * @return data[index]
     * @throws IllegalArgumentException 参数不合法异常
     */
    public T getIndexOf(int index) throws IllegalArgumentException{
        //参数合法性校验
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Illegal Index ！");
        }
        return this.data[index];
    }

    //修改值
    public void set(int index, T elem) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Illegal Index ！");
        }
        data[index] = elem;
    }

    /**
     * 按值查找 返回elem第一次出现的下标 未找到返回-1
     * @param elem
     * @return index
     */
    public int locationElem(T elem){

        for (int i = 0; i < this.size; i++) {

            if (elem.equals(this.data[i])) {
                return i;
            }
        }
        return -1;
    }

    //是否存在元素
    public boolean contains(T elem){
        return locationElem(elem) != -1;
    }

    //表是否为空
    public boolean isEmpty(){
        return (size == 0);
    }

    //表是否为空
    public boolean isFull(){
        return (size == data.length);
    }

    //获取容量
    public int getCapacity(){
        return data.length;
    }

    //在 index处插入一个元素
    public void add(int index, T elem) {

        //参数合法性校验

        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Illegal Index ! index is " + index);
        }

        if (isFull()) {
            updateCapacity(data.length * 2);
        }

        //在 index 后的数据后移
        for (int i = size; i > index; i--) {
            this.data[i] = this.data[i - 1];
        }

        this.data[index] = elem;

        size++;
    }

    //在数组首部添加元素
    public void addFirst(T elem) {
        add(0, elem);
    }

    //在数组尾部添加元素
    public void addLast( T elem){
        add(this.size,elem);
    }


    //更新数组容量
    public void updateCapacity(int newCapacity) {

        T[] newArray = (T[]) new Object[newCapacity];

        for (int i = 0; i < size; i++) { // copy原数组中的数据
            newArray[i] = data[i];
        }

        this.data = newArray;

    }

    //删除下标为index的元素并返回
    public T remove(int index){

        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Illegal Index ! index is " + index);
        }

        T elem = data[index];

        for (int i = index; i < size - 1; i++) {
            data[i] = data[i + 1];
        }

        size--;

        if (size < data.length / 2) { //缩容
            updateCapacity(data.length / 2);
        }

        return elem;
    }

    //删除第一个元素
    public T removeFirst() {
        return remove(0);
    }

    //删除最后一个元素
    public T removeLast() {
        return remove(size - 1);
    }

    //交换下标为 i 和 j 下标的值
    public void swap(int i, int j) {

        if (i < 0 || i >= size) {
            throw new IllegalArgumentException(" index is illegal !");
        }

        if (j < 0 || j >= size) {
            throw new IllegalArgumentException(" index is illegal !");
        }

        T temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }

    @Override
    public String toString() {

        StringBuilder res = new StringBuilder();

        res.append("SeqList{");

        res.append(" data=[");

        for (int i = 0; i < this.size; i++) {

            res.append(this.data[i].toString());

            if (i != size - 1) {
                res.append(',');
            }
        }
        res.append("], size=" + size +  ", capacity=" + getCapacity() + " }");

        return res.toString();
    }
}

基于二叉堆实现优先队列

普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。优先队列具有最高级先出 （first in, largest out）的行为特征。

由于二叉大顶堆的堆顶是堆中最大的元素，基于这个特点，我们很方便的就能基于二叉堆来实现优先队列这种数据结构。

package cn.boom.queue;

/**
 * 优先队列
 * @param <E>
 */
public class priorityQueue<E extends Comparable<E>> implements Queue<E> {

    private MaxBinaryHeap<E> maxBinaryHeap;

    public priorityQueue() {
        this.maxBinaryHeap = new MaxBinaryHeap<E>();
    }

    @Override
    public int getSize() {
        return maxBinaryHeap.getSize();
    }

    @Override
    public boolean isEmpty() {
        return maxBinaryHeap.isEmpty();
    }

    @Override
    public void enQueue(E e) {
        maxBinaryHeap.add(e);
    }

    @Override
    public E deQueue() {
        return maxBinaryHeap.extractMax();
    }

    @Override
    public E getFront() {
        return maxBinaryHeap.getMax();
    }
}
白日梦想家　
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树形结构----最大堆
NancyLCL的博客
02-16 592
1. 最大堆的定义：二叉堆是一颗完全二叉树( 区别于满二叉树 )，堆中某个结点的值总是不大于其父节点的值，通常这种堆称为最大堆( 相应的可以定义最小堆 )。下层的某一元素不一定小于上层的某一元素。 2. 最大堆的存储结构：既然是完全二叉树，所以可以用数组定义该结构。 如图就是一个最大堆： 3. 最大堆中的节点关系：因为是通过数组进行存储的，所以节点的角标就对应数组中的角标。 1>. 父节点角标：( 子节点角标 - 1 ) / 2。即" parent = ( i - 1 ) / ...
树形结构和堆
weixin_46129834的博客
02-02 513
树形结构和堆 可以改善优先队列的操作性能 一.线性和树形结构 首先分析效率低的原因: 按序插入操作低效,其根源是需要沿着表顺序检索插入位置,对于顺序表,需要移动O(n)个元素,对于链接表,需要顺着链接爬行O(n)步. 如果不改变数据的线性顺序存储方式,就不可能突破O(n)的复杂度限制, 要做出操作效率更高的优先队列,必须考虑其他数据结构组织方式 利用树形结构的祖先/子孙序,有可能得到更好的操作效率 一般而言,确定最优先元素并不需要与所有其他元素比较,以体育比赛中的淘汰赛为例,假设有n名选手参
树形数据结构---堆
最新发布
HH_KZ1314的博客
05-09 1012
我们能够看得出来这是一个大堆，这颗像树一样的图是它的逻辑结构，而底下的数组是它的物理结构，也就是说，我们真正操作的是数组。堆的特点是每个节点都满足堆的性质，即父节点的键值总是大于或等于（小于或等于）任何一个子节点的键值。堆分为最大堆和最小堆两种类型，其中最大堆的根节点键值是所有节点中最大的，最小堆的根节点键值是所有节点中最小的。堆在计算机科学中有着广泛的应用场景，其中最常见的应用之一是优先队列。5. **堆在操作系统中的应用**：堆内存管理是操作系统中的一个重要部分，用于动态分配内存给进程。
堆（树形结构应用）
weixin_51578598的博客
10-26 293
堆其实就是由完全二叉树组成的， 堆(heap) 堆（英语：heap)是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。 堆的性质： 1.堆中某个节点的值总是不大于或不小于其父节点的值。 2.堆总是一棵完全二叉树。 堆的分类 将根节点最大的堆叫做最大堆或大顶堆，根节点最小的堆叫做最小堆或小顶堆。常见的堆有二叉堆、斐波那契堆等。 堆的定义如下：n个元素的序列{k1,k2,ki,…,kn}当且仅当满足下关系时，称之为堆。 (ki <= k2i,ki <= k2i+1)
简单数据结构(队列 栈 树 堆 )
weixin_30929195的博客
07-17 251
基础知识 基本概念 程序 = 算法 + 数据结构 数据结构是计算机存储、组织数据的方式。 数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。 通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。 数据结构往往同高效的检索算法和索引技术有关。 常见数据结构 集合：set，multiset 线性...
数据结构之堆
Biexiansheng的博客
03-27 640
树结构的不同形态，堆、线段树、字段树、并查集，四种不同的树形数据结构。 1、优先队列，本身就是一种队列。普通队列，先进先出，后进后出。优先队列，出队顺序和入队顺序无关，和优先级有关，优先级高者先得，优先级高的先出队。 类别 入队 出队（拿出最大元素） 普通线性结构（数组、链表等） O(1)，直接将新的元素扔进去。 O(n)，需要扫描一遍元素，找出其优先级最高...
洛谷精选-树形数据结构例题（1）
12-29
来自洛谷的精选树形数据结构，覆盖线段树、可持久化线段树、树状数组、并查集、平衡树、堆、cdq分治等多种树形数据结构，写完之后轻松掌握树形数据结构！！！
数据结构作业：第1章概论.docx
12-14
3. 数据结构的分类：根据逻辑结构，数据结构主要分为集合、线性结构（如数组和链表）、树形结构（如二叉树、堆）和图状结构（如图和网络）。每种结构都有其特定的元素关系，例如线性结构中元素间是一对一的关系，树...
二叉树一种树形结构概念及特点
10-30
二叉树是一种树形结构，也是树形结构的一个重要类型，许多实际问题抽象出来的数据结构往往是二叉树形式。二叉树是 n 个有限元素的集合，该集合或者为空、或者由一个称为根（root）的元素及两个不相交的、被分别称为...
数据结构大全，从最基础的线性数据结构到树形数据结构，再到图论，排序算法
01-14
本资料包提供了一个全面的数据结构学习资源，涵盖了从基础的线性数据结构到复杂的树形结构，再到图论和排序算法的深度探讨。以下是关于这些主题的详细解释： 1. **线性数据结构**：线性数据结构是一类元素间存在一...
数据结构题库1800题.zip
08-24
6. **堆**：堆是一种特殊的树形数据结构，满足堆属性（最大堆或最小堆）。堆常用于优先队列的实现，以及快速找出最大或最小元素。 7. **散列表（哈希表）**：通过散列函数将键映射到数组中的位置，实现快速查找、...
【数据结构】堆——一种特殊的二叉树结构
weixin_74078718的博客
12-25 467
。
C++堆（数据结构堆也就是树状结构）排序
Haku_yyf的博客
03-11 407
#include&lt;iostream&gt; using namespace std; int arr[10] = { 2,8,3,9,1,4,6,7,0,5 }; void swap(int *a, int *b) { int temp = *a; *a = *b; *b = temp; } void show(int *arr,int n) { for (size_t i =...
堆这种数据结构
edui的博客
06-26 290
简要介绍堆的结构和实现，堆实现的话会出现相同元素时先进后出的情况，但是优先队列讲的是优先的先出来，优先一样的谁先出来都没关系，因为优先级都一样不用队列了，讲的是一种优先的排在前面而不是一定要保证先进先出。优先队列就是优先级当作队列，优先级一样不用当队列。
树形数据结构总结一（堆,Trie,并查集）
weixin_34101229的博客
05-30 190
树形结构是非常重要的一种数据结构。我们可以通过平衡二叉树来实现排序问题，用树结构来表示源程序的语法结构，树也可以表示数据库或文件系统。并且很多容器的底层都是树结构。 下面先来了解关于树结构的名词有哪些： 结点：表示树中的数据元素，A,B...H就是节点。 结点的度：结点所拥有的子树的个数，B的度为2。 树的度：树中各结点度的最大值，这里树的度为2。 叶子结点(Leaf Node)：度为0的结点...
[数据结构]~堆
分享技术
09-14 1330
有一组数据，我们将他们用完全二叉树的方式储存在一个一维数组中，并满足一定规律。 则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。
数据结构：堆（Heap）+图（Graph）
SHZNIU的博客
03-05 593
/* 数据结构与算法学习：堆 + 图 */ 堆： 一种特殊的树，必须满足的条件： 堆是一个完全二叉树； 堆中每一个节点的值都必须大于等于（或小于等于）其子树中每个节点的值。 大顶堆： 每个节点的值都大于等于子树中每个节点值的堆 小顶堆： 对于每个节点的值都小于等于子树中每个节点值的堆。 第 1 个和第 2 个是大顶堆，第 3 个是小顶堆，第 4 个不是堆。 堆的应用： 优先级队列； 合并有序小文件； 高性能定时器； 利用堆求TOP K； 利用堆求中位数。 图： 非线性表数据结构，在有向图中，我们把
堆
ClimberCoding
05-21 400
堆 1. 什么是堆 引： 优先队列：特殊的“队列”，取出元素的顺序是依照元素的**优先权(关键字)**大小，而不是元素进入队列后的先后顺序。 若采用数组或链表实现优先队列 是否可以采用二叉树的存储结构？ 不能用二叉搜索树：如果每次删除最大，最后会变为一颗斜树 堆！ 堆是一种常用的树形结构，是一种特殊的完全二叉树，当且仅当满足所有节点的值总是不大于或不小于其父节点的值的完全二叉树被称之为堆。 堆的两个特性 结构性：用数组表示的完全二叉树 有序性：任一结点的关键字是其子树所有结点的最大值（或最小值）
数据结构—堆的学习：堆化数组、堆的插入、堆的删除
u012258911的博客
08-28 2414
原网页：http://blog.csdn.net/morewindows/article/details/6709644 程序如下： //数据结构堆的创建（堆化数组）、堆的插入和删除 #include #include //交换两个元素值 void swap(int &a,int &b) { if(a!=b) { a=a^b; b=a^b; a=a^b; } } //从结点

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值