散列表(哈希表)

最新推荐文章于 2021-08-19 20:38:51 发布
最新推荐文章于 2021-08-19 20:38:51 发布
阅读量1.6k 收藏 2
点赞数 1
分类专栏： 数据结构与算法 文章标签： 散列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45893475/article/details/117136028
版权

散列表

知识点讲解可直接点击这里
代码参考：
https://blog.csdn.net/qq_35644234/category_6521704.html?spm=1001.2014.3001.5482

【问题】如何快速搜索到需要的关键词？如果关键词不方便比较怎么办？

查找的本质：已知对象找位置

  • 有序安排对象：全序、半序
  • 直接 “算出” 对象位置：散列

散列查找法的两项基本工作：

  • 计算位置：构造散列函数确定关键词存储位置
  • 解决冲突：应用某种策略解决多个关键词位置相同的问题

时间复杂度几乎是常数：O(1) ，即查找时间与问题规模无关！

1. 什么是散列函数

装填因子(Loading Factor)：设散列表空间大小为m，填入表中元素个数是n，则称α = n / m 为散列表的装填因子。

“散列(Hashing)” 的基本思想：

  1. 以关键字key为自变量，通过一个确定的函数h（散列函数），计算出对应的函数值h(key)，作为数据对象的存储地址
  2. 可能不同的关键字会映射到同一个散列地址上，即h(key i) = h(key j) (当key i ≠ key j)，称为“冲突(collision)”。——需要某种冲突解决策略

2. 散列函数的构造方法

一个 “好” 的散列函数一般应考虑下列两个因素：

  1. 计算简单，以便提高转换速度
  2. 关键词对应的地址空间分布均匀，以尽量减少冲突

2.1 数字关键词 的散列函数构造

  1. 直接定址法

    取关键词的某个线性函数值为散列地址，即h(key) = a * key + b（a、b为常数）

  2. 除留余数法

    散列函数为：h(key) = key mod p

    • 这里：p = tableSize = 17
    • 一般，p取素数

  3. 分析数字关键字在各位上的变化情况，取比较随机的位作为散列地址

  4. 折叠法

    把关键词分割成位数相同的几个部分，然后叠加

  5. 平均取中法

2.2 字符关键词 的散列函数构造

在这里插入图片描述

3. 冲突处理方法

常用处理冲突的思路：

  • 换个位置：开放地址法
  • 同一个位置的冲突对象组织在一起：链地址法

一旦产生了冲突（该地址已有其他元素），就按某种规则去寻找另一空地址。

  • 若发生了第 i 次冲突，试探的下一个地址将增加 di ，基本公式：hi(key) = (h(key) + di) mod tableSize (1 ≤ i < tableSize)。
  • di决定了不同的解决冲突方案：线性探测(di = i)、平方探测(di = ±i²)、双散列(di = i*h2(key))。

  • 线性探测法：以增量序列 1，2，… …，(tableSize - 1) 循环试探下一个存储地址。

  • 平方探测：以增量序列 1²，-1²，2²，-2²，… …，q²，-q² 且q ≤[tableSize / 2] 循环试探下一个存储地址

    有定理显示：如果散列表长度tableSize是某个 4k + 3 （k是正整数）形式的素数时，平方探测法就可以探查到整个散列表空间。

  • 分离链接法：将相应位置上的冲突的所有关键词存储在同一个单链表中

4. 散列表的性能分析

  • 平均查询长度(ASL)用来度量散列表查找效率：成功、不成功

  • 关键词的比较次数，取决于产生冲突的多少

    影响产生冲突多少有以下三个因素：

    1. 散列函数是否均匀
    2. 处理冲突的方法
    3. 散列表的填装因子α

4.1 线性探测法的查找性能

可以证明，线性探测法的期望探测次数 满足下列公式：

在这里插入图片描述

4.2 平方探测法和双散列探测法的查找性能

可以证明，平方探测法和双散列探测法探测次数 满足下列公式：

在这里插入图片描述

4.3 分离链接法的查找性能

所有地址链表的平均长度定义成 装填因子α，α有可能超过1。

可以证明：其期望探测次数p为：

在这里插入图片描述

4.4 总结&比较

  • 选择合适的 h(key)，散列法的查找效率期望是 常数O(1)，它几乎与关键字的空间的大小n无关！也适合于关键字直接比较计算量大的问题
  • 它是以 较小的α为前提。因此，散列方法是一个以 空间换时间
  • 散列方法的存储对关键字是随机的，不便于 顺序查找关键字，也不适合于 范围查找，或 最大值最小值查找。

开放地址法：

  • 优点：散列表是一个数组，存储效率高，随机查找
  • 缺点：散列表有 “聚集” 现象

分离链法：

  • 散列表是顺序存储和链式存储的结合，链表部分的存储效率和查找效率都比较低
  • 优点：关键字删除不需要 “懒惰删除” 法，从而没有存储 “垃圾” 。
  • 缺点：太小的 α 可能导致空间浪费，大的 α 又将付出更多的时间代价。不均匀的链表长度导致时间效率的严重下降。

5. 实现一个散列表

5.1第一次实现

#include <iostream>

using namespace std;

#define MAXSIZE 100
typedef int ElemType;
struct HashTable {
    ElemType* data; // 散列表存储数据数组
    int count;  // 插入数据的数量
    int size;   // 散列表的最大容量
};

void initHash(HashTable& H)
{
    H.size = MAXSIZE;
    H.count = 0;
    H.data = new ElemType[H.size];
    for (int i = 0; i < H.size; ++i) {
        H.data[i] = -99999;
    }
}

// 求散列函数，这里用 除留余数法
// 插入操作
bool insertHash(HashTable& H, ElemType key)
{
    if (H.count == H.size) {
        return false;
    }
    int index = key % H.size;   // 计算散列地址
    // 判断是否有冲突
    while (H.data[index] != -99999) {
        index = (index + 1) % H.size;
    }
    // 插入值
    H.data[index] = key;
    H.count++;
}

// 查找并返回索引位置
bool searchHash(HashTable& H, ElemType key, int& location)
{
    int index = key % H.size;   // 计算散列地址
    // 判断求出的散列地址是否为该值
    while (H.data[index] != key) {
        index = (index + 1) % H.size;
        // 不存在的情况，即一种散列地址处的值为初始值，另一种循环一圈到原位置
        if (H.data[index] == -99999 || index == key % H.size) {
            return false;   // 说明关键字不存在
        }
    }
    location = index;   // 存在，索引位置
    return true;
}

5.2 第二次实现

第一次实现的效果并不好，下面是第二次实现的成果

1. 开放地址法
/* ！！！线性探测 & 平方探测！！！*/

#include<iostream>
using namespace std;
typedef int keyType;
// 质数的集合
int hashsize[] = { 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107,
109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223,
227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337,
347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457,
461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593,
599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719,
727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857,
859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997 };

// 每次存储关键字空间的大小都是取质数 最接近的质数

struct Hash {
    keyType* data;  // 记录哈希表中的元素
    bool* isfull;   // 记录哈希表是否有元素了，标志位--------true说明不为空，false说明为空
    int count;      // 哈希表中已存放元素的个数
    int sizeindex;  // 对应的最接近的质数索引~Hashsize
};

void createHash(Hash& H) {
    H.count = 0;
    H.sizeindex = 0;
    H.data = new keyType[hashsize[H.sizeindex]];    // 初始哈希表的长度
    H.isfull = new bool[hashsize[H.sizeindex]];
    for (int i = 0; i < hashsize[H.sizeindex]; ++i) {
        H.isfull[i] = false;
    }
}

// 线性探测---查找对应的关键字
// p为最后插入的索引位置；c为偏移；hashsize为质数的集合--方便我们的计算
bool searchHash(Hash H, keyType key, int& p, int* hashsize) {
    int c = 0;
    p = key % hashsize[H.sizeindex];      // 计算要插入位置的索引
    while (H.isfull[p] && H.data[p] != key && c < hashsize[H.sizeindex] - 1) {
        ++c;
        //继续往下寻找下一个散列结点
        p = (key + c) % hashsize[H.sizeindex];
    }
    if (H.data[p] == key) {
        return true;    // 查找成功
    }
    return false;       // 查找失败 
}


// 平方探测---查找对应的关键字
bool searchHash(Hash H, keyType key, int& p, int* hashsize) {
    int c = 0;
    p = key % hashsize[H.sizeindex];      // 计算要插入位置的索引

    // 0^2，1^2,-1^2,2^2,-2^2,3^2,-3^2,4^2,-4^2...,q^2,-q^2），q<=m/2,m为散列表的长度
    while (H.isfull[p] && H.data[p] != key && c < hashsize[H.sizeindex] - 1) {
        if (c == 0) {
            c = 1;
            p = (key + c) % hashsize[H.sizeindex];
        }
        else if (c > 0) {
            c = -c;
            p = (key - c * c) % hashsize[H.sizeindex];
        }
        else {  // (c < 0)
            c = -c + 1;
            p = (key + c * c) % hashsize[H.sizeindex];
        }
    }
    if (H.data[p] == key) {
        return true;    // 查找成功
    }
    return false;       // 查找失败 
}

bool insertHash(Hash& H, keyType key, int* hashsize) {
    int p;      // 保存插入时索引的位置
    if (searchHash(H, key, p, hashsize)) { // 此时key已存在，不需要再插入
        return false;
    }
    // 下面的if语句判断在处理平方探测的时候还是有些问题的！
    else if (H.count == hashsize[H.sizeindex] - 1) {// 此时哈希表已经满，得重新分配了
        // 首先是把之前的内容保存起来
        ++H.sizeindex;
        keyType* data = new keyType[hashsize[H.sizeindex]];
        bool* isfull = new bool[hashsize[H.sizeindex]];
        for (int i = 0; i < hashsize[H.sizeindex - 1]; ++i) {
            data[i] = H.data[i];
            isfull[i] = H.isfull[i];
        }
        // 给新增加的标志位 添加标志
        for (int j = hashsize[H.sizeindex - 1]; j < hashsize[H.sizeindex]; ++j) {
            H.isfull[j] = false;
        }
        delete[] H.data;
        delete[] H.isfull;

        H.data = data;
        H.isfull = isfull;
    }
    else {
        // 插入key
        H.data[p] = key;
        ++H.count;
        H.isfull[p] = true;
    }
}

bool DeleteHash(Hash& H, keyType key, int* hashsize) {
    int p;
    if (!searchHash(H, key, p, hashsize)) {//没找到要删除的元素
        return false;
    }
    else {
        H.isfull[p] = false;
        --H.count;
    }
}

void print(Hash H, int* hashsize) {
    cout << "当前的哈希表的长度：" << hashsize[H.sizeindex] << endl;
    cout << "哈希表存有元素的个数：" << H.count << endl;
    cout << "打印整个哈希表：" << endl;
    for (int i = 0; i < hashsize[H.sizeindex]; ++i) {
        if (H.isfull[i]) {
            cout << H.data[i] << " ";
        }
        else {
            cout << "空" << " ";
        }
    }
    cout << endl;
}
2.链地址法
/*！！！链地址法！！！*/
#include<iostream>
using namespace std;
typedef int keyType;
// 质数的集合
int hashsize[] = { 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107,
109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223,
227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337,
347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457,
461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593,
599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719,
727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857,
859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997 };

struct Node {
    keyType data; //每个结点的值
    Node* next;  //下一个结点
    Node() {
        next = nullptr;
    }
};

// 每次都是取质数最接近的质数
struct Hash {
    Node* elem;     // 头结点链表
    int sizeindex;
};

// cur指向key所在的当前结点， pre指向~前一结点
bool searchHash(Hash H, keyType key, Node*& cur, Node*& pre, int* hashsize) {

    int index = key % hashsize[H.sizeindex];
    Node* head = H.elem[index].next;
    pre = nullptr;
    while (head) {  //遍历该链表
        cur = head;
        if (head->data == key) {
            return true;
        }
        pre = head;
        head = head->next;
    }
    return false;
}

// 插入
bool insertHash(Hash& H, keyType key, int* hashsize) {

    Node* cur = nullptr;
    Node* pre = nullptr;
    if (searchHash(H, key, cur, pre, hashsize)) {
        return false;
    }
    else {
        Node* s = new Node;
        s->data = key;
        if (pre == nullptr) {   
            int index = key % hashsize[H.sizeindex];
            H.elem[index].next = s;
            return true;
        }
        cur->next = s;
    }
    return true;
}

//删除结点
bool deleteHash(Hash& H, keyType key, int* hashsize) {
    Node* cur = nullptr;
    Node* pre = nullptr;
    if (!searchHash(H, key, cur, pre, hashsize)) {
        return false;
    }
    else {
        if (pre == nullptr) {
            int index = key % hashsize[H.sizeindex];
            H.elem[index].next = cur->next;
        }
        else {
            pre->next = cur->next;
        }
        delete cur;
        return true;
    }
}

void print(Hash H, int* hashsize) {
    Node* p = nullptr;
    for (int i = 0; i < hashsize[H.sizeindex]; ++i) {
        cout << i << " : ";
        p = H.elem[i].next;
        while (p) {
            cout << p->data << " ";
            p = p->next;
        }
        cout << "空" << endl;
    }
}
ClimberCoding
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
散列表（哈希表）
乳酸君在此
02-27 953
散列技术：散列技术是在记录的存储位置和它的关键字之间建立一个确定的对应关系f，使得每个关键字key对于一个存储位置f(key)。查找时，根据这个确定的对应关系找到给定值key的映射f(key)，若查找集合中存在这个记录，则必定在f(key)的位置上。通过查找关键字不需要比较就可以获得需要的记录的存储位置。 散列函数：这里我们把这种对应关系f称为散列函数，又称为哈希函数。 散列表（哈希表）：采用
散列表（哈希表）及其存储结构和特点详解
GDFHGFHGFH的博客
10-06 1301
文章参考地址 http://data.biancheng.net/view/107.html 散列表（哈希表）及其存储结构和特点详解 顺序存储的结构类型需要一个一个地按顺序访问元素，当这个总量很大且我们所要访问的元素比较靠后时，性能就会很低。散列表是一种空间换时间的存储结构，是在算法中提升效率的一种比较常用的方式，但是所需空间太大也会让人头疼，所以通常需要在二者之间权衡。我们会在之后的具体算法章节中得到更多的领悟。 什么是散列表 让我们想一下，若在手机通信录中查找一个人，那我们应该不会从第 1 个人一直
散列表基本常识(必知必会·理论篇)
热门推荐
执念斩长河
05-04 1万+
本博文源于浙江大学《数据结构》。散列（Hashing）是一种重要的查找方法。它的基本思想是：以数据对象的关键字key为自变量，通过一个确定的函数关系h，计算出对应的函数值h(key),把这个值解释为数据对象的存储地址，并按此存放，即“存储位置=h(key)”。
哈希表
aliven1的博客
05-26 3391
认识哈希表 哈希表是一种非常重要的数据结构，几乎所有的编程语言都直接或者间接应用这种数据结构。 哈希表通常是基于数组实现的，但是相对于数组，它存在更多优势： 哈希表可以提供非常快速的插入-删除-查找操作。 无论多少数据，插入和删除值都只需接近常量的时间，即O(1)的时间复杂度。实际上，只需要几个机器指令即可完成。 哈希表的速度比树还要快，基本可以瞬间查找到想要的元素。 哈希表相对于树来说编码要简单得多。 哈希表同样存在不足之处： 哈希表中的数据是没有顺序的，所以不能以一种固定的方式（比...
哈希表存储效率一般不超过50%
不积跬步无以至千里
10-01 2313
Hash Table 常用于频繁进行 key/value 模式的查找中。(查找模式，如匹配查找)   哈希表最大的优点在于查找速度快，但存储时可能发生collision(冲突)。   哈希表大多使用open addressing来解决collision，此时search的时间复杂度计算公式为：       1/( 1 - n/m )   其中，n与m分别表示存储
数据结构——hash散列表的存储效率一般不超过50%原因
qq_38330140的博客
09-22 2760
Hash Table 常用于频繁进行 key/value 模式的查找中。(查找模式，如匹配查找) 哈希表最大的优点在于查找速度快，但存储时可能发生collision(冲突)。 哈希表大多使用open addressing（开放定址法）来解决collision，此时search的时间复杂度计算公式为： 1/( 1 - n/m ) 其中，n与m分别表示存储的记录数与哈希表的长度，即装填因子( load factor ) 、负载因子n/m 故，若哈希表半满，即 n/m >= 1/2，则每次的searc
哈希表（散列表）
12-04
这个PPT讲了哈希表的基本原理和应用，还有字符串匹配的应用。
c语言或c++课程设计之散列表哈希表
12-31
在C语言或C++中，掌握散列表哈希表的设计是提升编程能力的重要环节。本篇文章将深入探讨散列表哈希表的基本概念、工作原理以及如何使用C或C++实现。 一、散列表哈希表基础 1. 哈希函数：哈希函数是散列表的核心，...
浅谈哈希表存储效率一般不超过50%的原因
12-25
本文主要是讲”哈希表的存储效率一般不超过50%”的原因。 Hash Table 常用于频繁进行 key/value 模式的查找中。(查找模式，如匹配查找) 哈希表最大的优点在于查找速度快，但存储时可能发生collision(冲突)。 哈希表大多使用open addressing来解决collision，此时search的时间复杂度计算公式为： 1/( 1 – n/m ) 其中，n与m分别表示存储的记录数与哈希表的长度，即装填因子( load factor ) 故，若哈希表半满，即 n/m >= 1/2，则每次的search次数可能会 >= 2 因此，为了保证Hash Table在 key/va
哈希表（散列表）原理详解 - CSDN博客1
08-03
哈希表，又称散列表，是一种高效的数据存储和查找结构，其主要原理是通过散列函数将关键码值（Key value）映射到一个固定大小的数组中的特定位置，从而实现快速访问。这个映射过程使得我们可以直接根据键（Key）来...
哈希表哈希表哈希表.zip
最新发布
05-29
哈希表，也被称为散列表，是计算机科学中一种高效的数据结构，用于存储和检索数据。它通过将关键字（key）映射到一个特定的位置来实现快速访问，这个位置称为哈希码或哈希值。哈希表的核心原理是利用哈希函数将...
哈希表相关操作实现
03-08
哈希表，也被称为散列表，是计算机科学中一种非常重要的数据结构，它提供了一种高效的数据存储和检索方法。哈希表通过将键（Key）映射到一个索引位置来实现快速访问，这个索引位置是通过哈希函数计算得出的。哈希...
数据结构与算法——深入理解哈希表
ChenTianyu的博客
05-28 2095
文章目录哈希表优点与缺点哈希化冲突基于线性探测的开放地址法插入查找删除性能问题基于二次探测的开放地址法基于再哈希法的开放地址法链地址法哈希表实现方法的选择参考 哈希表 哈希表是一种数据结构，基于数组实现，但存取方式和数组不同。 哈希表可以认为是一种特殊的数组，一个重要的特性是“数据项的关键字与数组下标有关联”。（数据项的关键字经过简单计算便可得到数组下标，从而实现快速存取） 优点与缺点 优点 提供快速的插入操作和查找操作，时间复杂度接近O(1)。 编程实现相对容易。 缺点 基于数组，一是创建后难
数据结构：哈希表理论
鸭绒的博客
10-25 1353
哈希表理论 哈希表是一种非常重要的数据结构, 很多学习编程的人一直搞不懂哈希表到底是如何实现的. 在这一章节中, 我们就一点点来实现一个自己的哈希表. 通过实现来理解哈希表背后的原理和它的优势. 一. 认识哈希表 我们还像其他数据结构一样, 先来简单的认识一下哈希表. 哈希表介绍 哈希表是一种非常重要的数据结构, 几乎所有的编程语言都有直接或者间接的应用这种数据结构. 哈希表通常是基于数组进行实现的, 但是相对于数组, 它也很多的优势: 它可以提供非常快速的插入-删除-查找操作 无论多少数据,
算法与数据结构 — 散列表
pentiumCM的博客
08-19 1684
文章目录算法与数据结构 — 散列表一、相关概念二、构建散列函数2.1 hash函数2.1.1 直接定址法2.1.2 除留余数法2.1.3 平方取中法2.1.4 折叠法2.1.5 数字分析法2.1.6 随机数法2.2 冲突处理2.2.1 拉链法2.2.2 开放定址法2.2.3 再散列法2.2.4 建立公共溢出区三、散列表查找3.1 查找过程3.2 查找性能 算法与数据结构 — 散列表 一、相关概念 散列表： 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问
哈希详解
骐骥一跃，不能十步；驽马十驾，功在不舍。
11-17 1934
1.应用背景 普通查找方法特点：通过将关键字值与给定值比较，来确定位置。效率取决比较次数。 理想的方法是：不需要比较，根据给定值能直接定位记录的存储位置。这样，需要在记录的存储位置与该记录的关键字之间建立一种确定的对应关系，使每个记录的关键字与一个存储位置相对应。 这就是我们要提起的哈希表 2.哈希（也称为Hash、杂凑、散列）基本思想        在记录的存储地址和它的关键字之间建立...
[数据结构]-散列表(哈希表)
隔壁老王三金的博客
04-10 1418
复习自《数据结构-邓俊辉版》 散列表 散列表(hashtable)是散列方法的底层基础，逻辑上由一系列可存放词条((或其引用)的单元组成，故这些单元也称作桶(bucket)或桶单元；与之对应地,各桶单元也应按其逻辑次序在物理上连续排列。因此，这种线性的底层结构用向量来实现再自然不过。为简化实现并进一步提高效率，往往直接使用数组，此时的散列表亦称作桶数组。若桶数组的容量为R，则其中合法秩的区间[...
散列表查找失败的asl
12-05
散列表查找失败的平均查找长度（ASL）可以通过以下公式计算：ASL = (1 + 1/（1-α）^2)/2，其中α为填装因子，表示哈希表中已经存储的元素个数与哈希表长度的比值。这个公式的推导可以参考引用中的线性探测法部分。在拉链法中，由于每个桶中可能存储多个元素，因此在查找失败的情况下，需要遍历哈希表中的所有桶，因此ASL的计算公式为：ASL = (1 + α)/2。这个公式的推导可以参考引用[2]中的拉链法部分。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ClimberCoding

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值