6.堆与优先队列

最新推荐文章于 2023-02-01 16:51:47 发布
最新推荐文章于 2023-02-01 16:51:47 发布
阅读量164 收藏
点赞数
分类专栏： 数据结构 文章标签： 队列 数据结构 堆排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nodd_le/article/details/115472774
版权

堆的概念

堆可以看成是一棵完全二叉树，除最后一层以外，它的每一层都是填满的，最后一层从左到右依次填入。对于堆上的任意一个结点来说，越接近顶部，结点的权值也就越大，并且它的权值大于等于它所在子树的所有结点的权值。我们对具有这样性质的完全二叉树叫做堆。

特别指出的是，如果一颗完全二叉树上每个结点的权值小于等于它所在子树的任意结点的权值，也被称为堆。为了区分这两种堆，我们把根结点权值大于等于树中结点权值的堆称为大顶堆，根结点权值小于等于树中结点权值的堆则称为小顶堆。

从逻辑上看，堆可以看成是一棵完全二叉树，具有 N 个元素的堆，高度为O(log N)。但实际上，我们并不需要真的维护一棵完全二叉树，而只需用一个数组来存储。堆按从上到下，从左到右的顺序，依次存储在下标从 1 开始的数组里。

  1. 编号为i的子节点，左孩子编号: 2*i，右孩子编号: 2*i+1
  2. 可以用连续空间存储(数组)

由于堆是一棵完全二叉树，堆的插入和删除操作的时间复杂度为 O(log N),log N指的就是这颗完全二叉树的高度。

堆有一个重要的性质，称为堆序性，即堆中每个结点的权值都大于等于（或小于等于）其子树任意结点的权值。

为了维护堆的堆序性，在修改堆中结点时会对堆进行调整，调整的时间复杂度为 O(log N)。堆的调整有两种，分别是自下而上的调整和自上而下的调整，即上滤和下滤。

堆通常用在堆排序里，堆排序是一种高效的排序算法，时间复杂度为O(N log N)。另外，堆也可以用于实现优先队列。

堆的实现

堆的构造实际上很简单，我们往往用一个数组来存储堆中的元素。在向堆中插入元素时，我们会先将新元素插入到堆的最后，即数组的末尾，之后再调整它的位置来维护堆的堆序性。

堆的插入操作算法流程如下：

  1. 把新元素保存在数组的最后。
  2. 找到新插入元素的父节点位置。
  3. 将新元素与父节点比较大小。
  4. 若新插入的元素与其父节点大小不符合堆序性则交换它和父节点的位置，并回到步骤2；若符合则插入操作完成。

删除堆顶的操作，我们都知道，堆的堆顶是数组中下标为0的元素。当然我们不能直接删除这个元素，让它之后的一个元素前移一位，显然这样会破坏堆序性。

删除堆顶元素操作的算法流程如下：

  1. 将堆顶元素和最后一个元素交换。
  2. 删除堆的最后一个元素。
  3. 自顶向下调整元素的位置，使之满足堆序性。
堆的基本操作
/*************************************************************************
	> File Name: 9.heap.c
	> Author: 陈杰
	> Mail: 15193162746@163.com
	> Created Time: 2021年04月06日 星期二 20时58分18秒
  > 堆的基本操作
************************************************************************/
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define swap(a, b) {\
    __typeof(a) _temp = a;\
    a = b, b = _temp;\
}
typedef struct Heap{
    int *data;
    int cnt;
}Heap;
/*
* 堆的初始化函数
* @param n: 初始化堆的存储大小
* */
Heap *init(int n) {
    Heap *h = (Heap *)malloc(sizeof(Heap));
    h->data = (int *) malloc(sizeof(int) * (n + 1));
    h->data[0] = n;                                 // 堆的第一个元素存储堆的大小
    h->cnt = 0;
    return h;
}
/*
* 判空
* @param h: 要操作的堆的指针
* */
int empty(Heap *h) {
    return h->cnt == 0;
}
/*
* 获取堆顶元素
* @param h: 要操作的堆的指针
* */
int top(Heap *h) {
    return h->data[1];
}
/*
* 堆插入元素
* @param h: 要操作的堆的指针
* @param val: 要插入元素的值
* */
int push(Heap *h,int val){
    if(h == NULL || h->cnt == h->data[0]) return 0;
    h->data[++(h->cnt)] = val;
    int ind = h->cnt;                               // 当前元素设为队尾元素
    // 自下往上处理堆序
    while(ind >> 1 && h->data[ind] > h->data[ind >> 1]) {
        swap(h->data[ind], h->data[ind >> 1]);
        ind >>= 1;
    }
    return 1;
}
/*
* 堆的弹出操作
* @param h: 要操作的堆的指针
* */
int pop(Heap *h) {
    if(h == NULL || empty(h)) return 0;
    h->data[1] = h->data[h->cnt--];
    int ind = 1;
    // 自上往下处理堆序
    while((ind << 1) <= h->cnt){
        int temp = ind, l = ind << 1, r = ind << 1 | 1;
        if(h->data[l] > h->data[temp]) temp = l;
        if(r <= h->cnt && h->data[r] > h->data[temp]) temp = r;
        if(temp == ind) break;
        swap(h->data[temp], h->data[ind]);
        ind = temp;
    }
    return 1;
}
/*
* 堆的打印
* @param h: 要操作的堆的指针
* */
void output(Heap *h) {
    printf("[");
    for(int i = 1; i <= h->cnt; i++) {
        i == 1 || printf(" ");
        printf("%2d", h->data[i]);
    }
    printf("]\n");
}
/*
* 堆的清理
* @param h: 要操作的堆的指针
* */
void clear(Heap *h) {
    if(h == NULL) return;
    free(h->data);
    free(h);
}
int main() {
    srand(time(0));
    #define MAX_OP 20
    Heap *heap = init(MAX_OP);
    for(int i = 0; i < MAX_OP; i++) {
        int val = rand() % 100;
        push(heap, val);
        printf("insert %d to the heap\n", val);
    }
    output(heap);
    for(int i = 0; i < MAX_OP; i++) {
        printf("%d\n", top(heap));
        pop(heap);
        output(heap);
    }
    clear(heap);
    #undef MAX_OP
    return 0;
}
堆排序

最后我们再来了解下堆排序的实现，我们以将一个大根堆由小到大进行排序为例。

堆排序的算法流程如下：

  1. 将变量 i 设为堆末下标。
  2. 交换堆顶和第 i 个元素。
  3. 自上到下调整堆顶到第 i 个元素之间的堆结构，使之保持堆序性。
  4. 将 i 前移一位，重复步骤2，直至 i等于 1。
/*************************************************************************
	> File Name: 9.heap_sort.c
	> Author: 陈杰
	> Mail: 15193162746@163.com
	> Created Time: 2021年03月24日 星期三 20时12分41秒
  > 堆排序-线性建堆法
************************************************************************/
#include<stdio.h>
#include <stdlib.h>
#include <time.h>
#define swap(a, b) {\
    __typeof(a) _temp = a;\
    a = b, b = _temp;\
}

void down_update(int *arr, int n, int ind) {
    while((ind << 1) <= n) {
        int temp = ind, l = ind << 1, r = ind << 1 | 1;
        if(arr[l] > arr[temp]) temp = l;
        if(r <= n && arr[r] > arr[temp]) temp = r;
        if(temp == ind) break;
        swap(arr[ind], arr[temp]);
        ind = temp;
    }
    return;
}

void heap_sort(int *arr, int n) {
    arr -= 1; // 编程小技巧
    // 建堆
    for(int i = n >> 1; i >= 1; i--) {
        down_update(arr, n, i);
    }
    // 排序
    for(int i = n; i > 1; i--) {
        swap(arr[i], arr[1]);
        down_update(arr,i - 1, 1);
    }
    return;
}
void output(int *arr, int n) {
    printf("[");
    for(int i = 0; i < n; i++) {
        i == 0 || printf(" ");
        printf("%d",arr[i]);
    }
    printf("]\n");
}
int main() {
    srand(time(0));
    #define MAX_OP 20
    int *arr = (int *)malloc(sizeof(int) * MAX_OP);
    for(int i = 0; i < MAX_OP; i++) {
        arr[i] = rand() % 100;
    }
    output(arr, MAX_OP);
    heap_sort(arr, MAX_OP);
    output(arr, MAX_OP);
    #undef MAX_OP
    free(arr);
    return 0;
}

优先队列

利用队列先进先出的性质，可以解决很多实际问题，但对于一些特殊的情况，队列是无法解决的。例如，在医院里，重症急诊患者肯定不能像普通患者那样依次排队就诊。这个时候，我们就需要一种新的数据结构——优先队列，先访问优先级高的元素(例如这里的重症急诊患者)。

在队列中，元素从队尾进入，从队首删除。相比队列，优先队列里的元素增加了优先级的属性，优先级高的元素先被删除。

优先队列内部一般是用堆来实现的。我们知道堆的插入、删除操作的时间复杂度都是O(log n)，自然优先队列的插入、删除操作的时间复杂度也都是O(log n)。堆中的堆顶元素就是优先队列的队首元素。

对于大根堆实现的优先队列，总是优先级高的元素先被删除。相对的，对于小根堆实现的优先队列，总是优先级低的元素先被删除。对于后者，我们也称之为优先队列。优先队列还能解决任务调度问题，例如操作系统的进程调度问题。

在 C++ 的 STL 里，有封装好的优先队列priority_queue，它包含在头文件<queue>里。优先级可以自己定义，默认优先级是权值大的元素优先级高。优先队列是一种用途广泛的数据结构，它能巧妙高效的解决很多其他数据结构不容易解决的问题。

哈夫曼编码

哈夫曼编码是 1952 年由 David A. Huffman 提出的一种无损数据压缩的编码算法。哈夫曼编码先统计出每种字母在字符串里出现的频率，根据频率建立一棵路径带权的二叉树，也就是哈夫曼树，树上每个结点存储字母出现的频率，根结点到结点的路径即是字母的编码，频率高的字母使用较短的编码，频率低的字母使用较长的编码，这样使得编码后的字符串占用空间最小。

首先统计每个字母在字符串里出现的频率，我们把每个字母看成一个结点，结点的权值即是字母出现的频率，我们把每个结点看成一棵只有根结点的二叉树，一开始把所有二叉树都放在一个集合里，接下来开始如下编码：

  • 步骤一：从集合里取出两个根结点权值最小的树a和b，构造出一棵新的二叉树c，二叉树c的根结点的权值为a和b的根结点权值和，二叉树c的左右子树分别是a和b。
  • 步骤二：将二叉树a和b从集合里删除，把二叉树c加入集合里。
  • 重复以上两个步骤，直到集合里只剩下一棵二叉树，最后剩下的就是哈夫曼树了。

我们规定每个有子节点的结点，到左子节点的路径为0，到右子节点的路径为1.每个字母的编码就是根结点到字母对应结点的路径。

/*************************************************************************
	> File Name: 5.halfman.c
	> Author: 陈杰
	> Mail: 15193162746@163.com
	> Created Time: 2021年05月15日 星期六 22时53分19秒
 ************************************************************************/
#include<stdio.h>
#include<stdlib.h>
#include <string.h>
typedef struct Node {
    char ch;   // 当前结点是否独立成词
    double freq;
    struct Node *lchild, *rchild;
} Node;
typedef struct Heap {
    Node **data;
    int n, cnt;
} Heap;

Node *getNewNode(char ch,double freq, Node *lchild, Node *rchild) {
    Node *p = (Node *)malloc(sizeof(Node));
    p->freq = freq;
    p->ch = ch;
    p->lchild = lchild;
    p->rchild = rchild;
    return p;
}
void clear(Node *root) {
    if (root == NULL) return;
    clear(root->lchild);
    clear(root->rchild);
    free(root);
}
Heap *init_heap(int n) {
    Heap *h = (Heap *)malloc(sizeof(Heap));
    h->data = (Node **)malloc(sizeof(Node *) * (n + 5));
    h->n = n;
    h->cnt = 0;
    return h;
}
Node *top(Heap *h) {
    return h->data[1];
}
int empty(Heap *h) {
    return h->cnt == 0;
}
#define swap(a, b) {\
    __typeof(a) _temp = a;\
    a = b, b = _temp;\
}
int less(Node *n1, Node *n2) {
    return n1->freq < n2->freq;
}
void push(Heap *h, Node *node) {
    h->data[++h->cnt] = node;
    int ind = h->cnt;                               // 当前元素设为队尾元素
    // 自下往上处理堆序
    while(ind >> 1 && less(h->data[ind], h->data[ind >> 1])) {
        swap(h->data[ind], h->data[ind >> 1]);
        ind >>= 1;
    }
    return;
}
void pop(Heap *h) {
    if(empty(h)) return;
    h->data[1] = h->data[h->cnt--];
    int ind = 1;
    // 自上往下处理堆序
    while((ind << 1) <= h->cnt){
        int temp = ind, l = ind << 1, r = ind << 1 | 1;
        if(less(h->data[l],h->data[temp])) temp = l;
        if(r <= h->cnt && less(h->data[r],h->data[temp])) temp = r;
        if(temp == ind) break;
        swap(h->data[temp], h->data[ind]);
        ind = temp;
    }
}
int size(Heap *h) {
    return h->cnt;
}
void clearHeap(Heap *h) {
    if(h == NULL) return;
    free(h->data);
    free(h);
}
Node* buildHalfman(Heap *h) {
    while(size(h) > 1) {
        Node *a = top(h); pop(h);
        Node *b = top(h); pop(h);
        push(h, getNewNode(0, a->freq + b->freq, a, b));
    }
    return top(h);
}
void getHalfmanCode(Node *root, int k, char *buff, char *code[]) {
    if(root == NULL) return;
    buff[k] = 0;
    if(root->ch) {
        code[root->ch] = strdup(buff);
        return;
    }
    buff[k] = '0';
    getHalfmanCode(root->lchild, k + 1, buff, code);
    buff[k] = '1';
    getHalfmanCode(root->rchild, k + 1, buff, code);
}
int main () {
    int n;
    scanf("%d", &n);
    Heap *h = init_heap(n);
    for(int i = 0; i < n; i++) {
        char ch[10];
        double freq;
        scanf("%s %lf", ch, &freq);
        push(h, getNewNode(ch[0], freq, NULL, NULL));
    }
    Node *root = buildHalfman(h);
    char *code[256] = {0}, buff[100];
    getHalfmanCode(root, 0, buff, code);
    for(int i = 1; i < 256; i++) {
        if(code[i] == 0) continue;
        printf("%c %s\n", i, code[i]);
    }
    clearHeap(h);
    return 0;
}

刷题时候的临时堆

/*************************************************************************
	> File Name: temp_heap.c
	> Author: 陈杰
	> Mail: 15193162746@163.com
	> Created Time: 2021年07月01日 星期四 21时15分52秒
  > 零时简易堆
*************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#define swap(a, b) {\
    __typeof(a) _temp = a;\
    a = b, b = _temp;\
}
#define MAX_SIZE 10
void down_to_up(int *heap, int ind) {
    while(ind >> 1 && heap[ind] > heap[ind >> 1]) {
        swap(heap[ind], heap[ind >> 1]);
        ind >>= 1;
    }
}
void up_to_down(int *heap, int cnt) {
    int ind = 1;
    while((ind << 1) <= cnt) {
        int temp = ind, l = ind << 1, r = ind << 1 | 1;
        if(heap[l] > heap[temp]) temp = l;
        if(r <= cnt && heap[r] > heap[temp]) temp = r;
        if(temp == ind) break;
        swap(heap[temp], heap[ind]);
        ind = temp;
    }
}
int main() {
    int ind = 0, heap[MAX_SIZE];
    for(int i = 1; i < MAX_SIZE; i++) {
        int val = rand() % 100;
        // push
        heap[++ind] = val;
        down_to_up(heap, ind);
    }
    while(ind) {
        printf("max value : %d\n", heap[1]);
        heap[1] = heap[ind--];
        up_to_down(heap, ind);
    }
    return 0;
}
nodd_le
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解堆与优先队列
⚡
01-31 2003
详解堆、堆排序与优先队列的概念
优先队列与堆
能能
07-25 1181
优先队列与堆 优先队列与堆 一 优先队列 1.1 定义 1.2 API 1.3 实现 二 堆 2.1 定义 2.2 表示 2.3 堆的有序化 2.4 基于堆的优先队列 一 优先队列 1.1 定义 在很多应用中，我们通常需要按照优先级情况对待处理对象进行处理，比如首先处理优先级最高的对象，然后处理次高的对象。最简单的一个例子就是，在手机上玩游戏的时候，如果有...
【数据结构】堆，大根堆，小根堆，优先队列 详解
繁凡さん的博客
02-24 1万+
堆 要了解堆之前,请先了解树,因为堆是一颗完全二叉树 如果不知道的话请点击下方链接了解 树,二叉树,完全二叉树详解 要注意的是 首先堆是一颗完全二叉树 其次堆中存储的值是偏序 Min-heap(小根堆): 父节点的值小于或等于子节点的值 Max-heap(大根堆): 父节点的值大于或等于子节点的值 好吧其实就是实现自动排序 O（logn）时间复杂度内实现插入，删除，O（1）查询 1....
数据结构——优先级队列和堆
最新发布
xh1605004242的博客
02-01 2607
优先级队列、堆及其区别
＜数据结构＞堆和堆排序
weixin_63246064的博客
05-25 346
目录 一、堆的概念及结构 二、堆的实现 2.1.堆向下调整算法 2.2.堆的创建 2.3.建堆时间复杂度 2.4.堆的插入 2.5.堆的删除 三、堆的应用 3.1. 堆排序 3.2. TOP-K问题 一、堆的概念及结构 如果有一个关键码的集合K = { ， ， ，…， }，把它的所有元素按完全二叉树的顺序存储方式存储 在一个一维数组中，并满足： = 且 >= ) i = 0，1， 2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆
【浅学Java数据结构】 优先级队列以及堆的创建、插入、删除
qq_52276036的博客
05-30 1793
优先级队列 （PriorityQueue）1. 优先级队列1.1 概念2. 优先级队列的模拟实现2.1 堆的概念2.2 堆的存储方式3. 堆的创建3.1 堆的向下调整3.2 建堆的时间复杂度4. 堆的插入和删除4.1 堆的插入4.2 堆的删除5. 用堆模拟优先级队列6. 常用接口介绍6.1 PriorityQueue的特性6.2 PriorityQueue常用接口介绍7. 优先级队列的应用 1. 优先级队列 1.1 概念 前面介绍过队列，队列是一种先进先出(FIFO)的数据结构，但有些情况下，操作的数
算法 - 常用技巧
weianluo的博客
08-23 213
动态维护区间 352. 将数据流变为多个不相交区间 https://leetcode-cn.com/problems/data-stream-as-disjoint-intervals/
利用顺序表实现优先队列的插入和删除操作
summy_o的专栏
04-12 2983
#pragma once  //防止重命名 #define SIZE 10   //对于顺序表，首先假定初始化大小为10 typedef struct sqlist {  int elem[2][SIZE]; //由于要保存数据data、优先级prio，因此定义为二维数组  int length; }sqlist,*psqlist; bool Insert_Queue(psqlist
堆（MinHeap && MaxHeap）建堆两种方式 堆排序
来啦(#^.^#)
08-03 850
一、概念 大根堆：根节点（堆顶）值是所有节点中最大的；又称最大堆。根节点值比其左右子树的节点值都要大； 小根堆：根结点值是最小值； 【注意】1. 堆中任一子树也是堆； 2. 堆的本质是一棵完全二叉树 二、堆排序 参考博客 堆也是一种数据结构，从实际应用意义来说，他是一种最优级别数据永远在第一位的队列，本文皆以最小值为例（小顶堆），即它变相是一种会永远保持最小值先出队的队列。 堆...
数据结构与算法分类练习－－栈 队列 堆
明日世界
07-26 248
栈 LIFO: last-in, first-out 后进先出。两种操作：PUSH－－压入；POP－－弹出。 python中可以使用list来实现栈。PUSH操作相当于list.append(x)，POP操作相当于list.pop()。 队列 FIFO: first-in, first-out 先进先出。队列有队头和队尾，当一个元素入队时，被放在队尾的位置；而出队的元素则总是在队头的那个。...
优先级队列--大根堆和小根堆
sinat_40408114的博客
08-10 3346
概述 与FIFO的普通队列不同，在优先级队列中，元素出队顺序是由元素的优先级决定。比如大根堆是最大的元素先出队，小根堆是最小的元素先出队。 堆是实现优先级队列效率很高的数据结构(当然我们也可以使用无序的线性表或者有序链表来实现，但是它们的删除、插入的时间复杂度至少有一个是O(n))。堆是一棵完全二叉树，这样就保证了底层存储的数组拥有很高的空间利用率。无论是大根堆还是小根堆，它们的插入和删除的复杂性...
堆排序及其复杂度分析
扬奇的博客
01-17 2047
以升序排序为例，大顶堆实现： package leetcode.sort.compare.select; import java.util.Arrays; public class HeapSort { public void downAdjust(int[] array, int parentIndex, int length) { int largestIndex = parentIndex; int lChildIndex = 2 * parent..
优先队列和堆，与priority_queue的学习笔记
昀光Icrus的博客
04-19 713
今天花了一天的时间把优先队列和堆，还有priority_queue给学习了学习，现在做下笔记。学完认识到优先队列就是堆的一种，而priority_queue是为优先队列准备的STL，定义与使用起来十分方便。堆先说堆，堆是一个二叉树，以小根堆为例（大根堆就相反了）儿子的值一定不小于父亲的值，可用数组保存，插入数值时先在堆的末尾插入该数值，然后不断向上交换，将优先级大（即数值较小的）的交换上去直到没有...
数据结构之堆
热门推荐
morris
07-01 1万+
思考 假如需要设计一种数据结构，用来存放整数，要求提供3个接口： 添加元素 获取最大值 删除最大值 如果使用动态数组、双向链表和二叉树实现这个数据结构对应的时间复杂度如下表所示： 添加元素 获取最大值 删除最大值 说明 动态数组\双向链表 O(1) O(n) O(n) 有序动态数组\双向链表 O(n) O(1) O(1) 全排序有点浪费 平衡二叉搜索树 O(logn) O(logn) O(logn) 杀鸡焉用牛刀 有没有更优的数据结构？使用堆，可以使得获取最大值的时间复杂
优先队列－堆
三哥的博客
03-06 3678
优先队列　　队列是一个操作受限的线性表，数据只能在一端进入，另一端出来，具有先进先出的性质。有时在队列中需要处理优先级的情况，即后面进入的数据需要提前出来，这里就需要优先队列。优先队列是至少能够提供插入和删除最小值这两种操作的数据结构。对应于队列的操作，插入相当于入队，删除最小相当于出队。 　　链表，二叉查找树，都可以提供插入和删除最小这两种操作。对于链表的实现，插入需要O(1)，删除最小需要遍历
堆的相关操作（创建堆、插入、删除、堆排序、top-k问题）
weixin_62042704的博客
12-08 3130
一、什么是堆 堆得满足两个特性：1、首先得是一个完全二叉树 2、每个节点比其孩子节点都大（小），则其是大（小）堆。 堆是将其元素存储在一维数组中的。 二、堆的创建 1、首先了解堆向下调整算法： 向下调整算法有一个前提：左右子树必须得是一个堆。如图所示，只有根节点不满足堆的特性。 现在就来向下调整根节点，使其整体成为一个小堆。具体做法是让父节点和它较小的子节点交换（前提是左右节点都存在），然后再让父节点等于子节点；重复此操作...
二叉堆操作时间复杂度分析
行走巨人国
12-30 7772
转载自：https://blog.csdn.net/jmh1996/article/details/83662953 本blog主要介绍了二叉堆、二项式堆，下一篇博客将介绍斐波拉契堆。 二叉堆和二项式堆、斐波拉契堆都是用于实现优先队列的高级数据结构，以不同堆实现的优先队列会有不同的时间复杂度。 问题引入 在实际应用中，我们经常会遇到在最多由n个数组成的动态集合S SS上得到这个集合里面的最大...
Java实现二叉查找树、堆与优先队列详解
总结来说，这篇文章介绍了Java中二叉查找树的实现、基本操作以及与之相关的堆和优先队列的概念。理解并掌握这些概念和代码实现对于深入理解数据结构和算法至关重要，尤其是在处理需要快速查找、插入和删除元素的场景...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值