数据结构之字符串

最新推荐文章于 2023-11-04 23:39:07 发布
最新推荐文章于 2023-11-04 23:39:07 发布
阅读量721 收藏 1
点赞数
分类专栏： 数据结构及经典算法：C语言实现 算法C语言实现 文章标签： 算法 索引
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010710458/article/details/78887755
版权

字符串算法简介

字符串排序

键索引计数法

应用领域：
1、通过字符串一个字符排序。
2、将全班同学按组分类。
3、通过地区码排序电话号码。

这是一种用于小整数键的排序方法。只需要理解下面的实际问题即可理解键索引计数法排序。
这里写图片描述
对于ASCII字符，我们可以直接用ASCII对应的数值作为键，初始化count数组，然后在数组里面记录，每一个ASCII字符出现的次数，进而转化成字符在结果数组里面的初始化位置。然后通过获得初始化位置进行排序。思路很简单，直接看代码就可以清楚。

//ASCII表的值作为字符对应的键
//通过索引键出现的次数，找到键在结果排序中的起始位置。
//然后遍历字符串进行排序
void KeyIndexCounting(char *source)
{
    int R = 128,i;//标准ascii对应最大数值
    int N = strlen(source);
    int count[R+1];//
    char *aux = (char *)malloc(N);//分配暂存数组
    memset(count , 0 , sizeof(count));//将栈上数据清0
    for(i = 0 ; i < N ; i++)
        count[source[i]+1]++;//计算键出现的频率，存储在键+1的位置，方便后面计算起始位置。

    for(i = 0 ; i < N ; i++){
        printf("%c %d\n" , source[i] , count[source[i]+1]);
    }

    for(i = 0  ; i < R ; i++)
        count[i+1] += count[i];//计算键在结果数组中出现的初始化位置
    for(i = 0 ;i < N ; i++)
        aux[ count[source[i]]++ ] = source[i];//遍历一次字符串，将字符放到aux合适位置
    for(int i = 0 ; i < N ; i++)
        source[i] = aux[i];//将排好序的字符串拷贝回原数组
    free(aux);
}
void main(void)
{
    char p[] = "lkjhgfdsawqwrtyuioknvbc";//字符串常量不可更改
    printf("%s\n" , p);
    KeyIndexCounting(p);
    printf("%s\n" , p);
}

这里写图片描述
键索引计数法不需要比较字符，仅仅需要遍历几次字符串即可，是一个线性级别的排序方法。

低位优先字符串排序

低位优先排序从右向左检查每个字符，每检查一次则排序一次，低位优先字符串排序要求待排序的字符串长度至少都为w位。
低位优先字符串排序和基数排序非常的相似。假设字符串的长度为W，首先以最低位W-1位为键进行排序，再以W-2位为键进行排序，……，直到以0位为键进行排序，此时排序的结果就是最终的结果。显而易见，低位优先字符串排序是稳定排序。无论字符串数组N多大，都只需要遍历w次数据即可排序成功。下面直接上代码

 /*
通过LSD排序字符串数组。从w到1位开始排序。
只需要通过w次键索引计数法即可排序成功。
指针数组，传入p则是指向指针的指针，p指针数组的维度，通过低位的w个字符排序。
*/
void LSDSort(char **p , int p_length ,  int w)
{
    int R = 128,i,d;
    int N = p_length;//p中元素个数
    int count[R+1];

    char **aux = (char **)malloc(sizeof(char *) * N);//分配暂存指针数组
    for(d = w-1 ; d >= 0 ; d--){
        memset(count , 0 , sizeof(count));//将数据清0，为下次键索引计数准备
        for(i = 0 ; i < N ; i++)
            count[p[i][d]+1]++;//计算键出现的频率，存储在键+1的位置，方便后面计算起始位置。
        for(i = 0  ; i < R ; i++)
            count[i+1] += count[i];//计算键在结果数组中出现的初始化位置
        for(i = 0 ;i < N ; i++)
            aux[count[p[i][d]]++] = p[i];//遍历一次字符串，将字符放到aux合适位置
        for(int i = 0 ; i < N ; i++)
            p[i] = aux[i];//将排好序的字符串拷贝回原数组
    }
    free(aux);
}
int main(void)
{
    char *s[] = {
        "4PGC938",
        "2IYE230",
        "3CIO720",
        "1ICK750",
        "1OHV845",
        "4JZY524",
        "1ICK750",
        "3CIO720",
        "1OHV845",
        "1OHV845",
        "2RLA629",
        "2RLA629",
        "3ATW723",
    };
    int s_length = sizeof(s)/sizeof(s[0]);
    for(int i = 0 ; i < sizeof(s)/sizeof(s[0]) ; i++)
        printf("%s\n" , s[i]);
    LSDSort(s , s_length , 7);
    printf("after sort:\n");
    for(int i = 0 ; i < sizeof(s)/sizeof(s[0]) ; i++)
        printf("%s\n" , s[i]);
    return 0;
}

排序过程：
这里写图片描述
性能：
这里写图片描述
输出结果：
这里写图片描述

高位优先字符串排序

单词查找树

子字符串查找

字符串题目

1、下面运行结果

int main(void)
{
    char str1[] = "hello world";
    char str2[] = "hello world";
    char *str3 = "hello world";
    char *str4 = "hello world";
}

要点：常量字符串在内存空间中只有一份副本。所以str3 = str4指向同一个副本。str1和str2是数组，局部变量，里面存放12个字符，所以str1 != str2。

2、替换空格

题目:请实现一个函数，把字符串中的每个空格替换成”%20”，例如输入”We are happy.”，则输出 “We%20are%20happy.”。
方法：在原字符串替换，则需要保证字符串后面空间足够；否则需要新键字符串。
注意：计算新字符串所需要空间的时候，必须考虑结束符。指针可以通过两个索引来保证。这样事件复杂度为O(n)。也要注意防御性编程，这是真的值得注意的。
这里写图片描述

//确保string对应的内存空间足够
void ReplaceBlank(char *string , int length)
{
    //防御性编程
    if(string == NULL || length <= 0)
        return ;
    int stringlength = 0;//记录字符串长度
    int numofblank = 0;//记录空格长度
    char *s = string;
    while( *s != '\0'){//统计字符个数包括结束符 和 空格个数
        stringlength++;
        if(*s == ' ')
            numofblank++;
        s++;//指向下一个字符
    }
    stringlength++;//加上结束符才是字符串长度
    int newlength = stringlength + numofblank*2;//新字符长度,考虑结束字符

    //防御性编程,内存空间不够
    if(newlength > length)
        return;
    int indexOfold = stringlength -1;//指向旧的最后一个字符
    int indexOfnew = newlength - 1;//指向新的最后一个字符
    while(indexOfold != indexOfnew){
        if(string[indexOfold] == ' '){//替换
            string[indexOfnew--] = '0';
            string[indexOfnew--] = '2';
            string[indexOfnew--] = '%';
            indexOfold--;
        }else
            string[indexOfnew--] = string[indexOfold--];
    }
}

3、实现strstr

const char* mystrstr(const char *str1, const char *str2)
{
  if(NULL == str1 || NULL == str2)
      return NULL;
  while(*str1 != '\0')
  {
      const char *p = str1;
      const char *q = str2;
      const char *res = NULL;
      if(*p == *q) //比较后序
      {
            res = p;
            while(*p && *q && *p++ == *q++);
            if(*q == '\0')//如果比较结束
                  return res;//返回
      }
      str1++;
  }
  return NULL;
}

3、实现strcpy memcpy(考虑重叠情况) strcat strcmp

当实现memcpy的时候，应该考虑是否重叠的问题。重叠主要分为两种情况。
这里写图片描述
这是第一种情况，des+n比src大，这是第一种重叠情况，但是最终可以将src正确的成功复制到des起始的位置，这种情况memcpy暂时不考虑。
这里写图片描述
这是第二中情况，src+n比des大，这种情况如果按照第一种方式复制，会导致最后des起始开始的位置数据发送错误。如上图最后des开始的就是12312。这种情况就需要倒过来复制。下面的代码就是基于这种思路实现出来的。

char* strcpy(char* dst, const char* src)
{
    assert(dst);
    assert(src);
    char* ret = dst;
    while((*dst++ = *src++) != '\0');//碰到src的字符串尾停止
    return ret;
}//该函数是没有考虑重叠的


//字符串考虑重叠拷贝
char* strcpy(char* dst, const char* src)
{
    assert( (dst != NULL) && (src != NULL) );//非空检测，错误则报错处理
    if(dst == src)//地址相等，则直接返回
        return src;
    char* ret = dst;
    int size = strlen(src) + 1;//考虑字符串结束符'\0'

    if(dst > src && dst < src + len)//dest位于src+len中间,则当做重叠处理
    {
        dst = dst + size - 1;
        src = src + size - 1;
        while(size--)
        {
            *dst-- = *src--;//倒过来拷贝
        }
    }
    else
    {
        while(size--)
        {
            *dst++ = *src++;
        }
    }
    return ret;
}

//内存考虑重叠拷贝
//此函数可以防止重叠
//memcpy函数的功能是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中
void* memcpy(void* dst, const void* src, size_t size)//void决定可以输入任意类型
{
    if(dst == NULL || src == NULL)
    {
        return NULL;
    }
    void* res = dst;
    char* pdst = (char*)dst;//强转为char*
    char* psrc = (char*)src;//强转为char*

    if(pdst > psrc && pdst < psrc + size) //重叠
    {
        pdst = pdst + size - 1;//地址增加size个
        psrc = pdst + size - 1;//
        while(size--)
        {
            *pdst-- = *psrc--;//倒过来拷贝
        }
    }
    else //无重叠
    {
        while(size--)
        {
            *dst++ = *src++;//优先级问题注意了
        }
    }
    return ret;
}

char* strcat(char* dst, const char* src)
{
    char* ret = dst;

    while(*dst != '\0')//找到dst字符串尾
        ++dst;

    while((*dst++ = *src) != '\0');//然后拷贝，找到src尾部
    return ret;
}

//手写strcmp函数
int strcmp(const char* str1, const char* str2)
{

    while(*str1 == *str2 && *str1 != '\0')
    {
        ++str1;
        ++str2;
    }
    return *str1 - *str2;//相等则是0，返回正数或者负数则不等。
}

4、字符串移位包含的问题

const char* mystrstr(const char *str1, const char *str2)
{
  if(NULL == str1 || NULL == str2)
      return NULL;
  while(*str1 != '\0')
  {
      const char *p = str1;
      const char *q = str2;
      const char *res = NULL;
      if(*p == *q) //比较后序
      {
            res = p;
            while(*p && *q && *p++ == *q++);
            if(*q == '\0')//如果比较结束
                  return res;//返回
      }
      str1++;
  }
  return NULL;
}
bool FindStr(char *str1 , char *str2)
{
    if(!str1 || !str2)
        return false;
    int len1 = strlen(str1);
    for(int i  = 0 ; i < len1 ; i++){//进行len次循环移位,每次进行字符串包含判断
        char temp = str1[0];
        for(int j = 0 ; j < len1 - 1 ; j++)
            str1[j] = str1[j+1];
        str1[len1 - 1] = temp;
        if(mystrstr(str1 , str2) != 0){
            return true;
        }
    }
    return false;
}
int main()
{
    char src[] = "AABCD";
    char des[] = "CDAA";
    printf("%d\n" , FindStr(src , des)? 1 :0);
}

这里写图片描述

5、翻转单词顺序

牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？

class Solution {
public:
    string ReverseSentence(string str) {
        //直接使用编译器帮我我们自动创建的栈变量str，注意必须通过值返回，否则析构出错
        if(str.empty())
            return str;
        Reverse(str , 0 , str.size() - 1);//先整体反转str，这个str在栈上面，涉及一次拷贝构造哦，搞完右析构，比较麻烦的
        int start = 0;
        int end = 0;
        int i = 0;
        while(i < str.size()){
            while(i < str.size() && str[i] == ' ')//跳过空格
                 i++;//
            start = end = i;//记录单词第一次出现位置
            while(i < str.size() && str[i] != ' '){//找到单词最后一个位置
                i++;//j记录找到的位置。
                end++;
            }
            //找到了一个单词，开始反转
            Reverse(str , start , end-1);//局部单词反转
        }
        return str;
    }
private:
    void Reverse(string &s , int start , int end){
        if(s.empty())
            return;
        while(start < end)//反转string指定的开始和结束位置，通过传引用获取的效果
            swap(s[start++] , s[end--]);
    }
};

6、左旋转字符串

汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

个人觉得做题目还是用C语言比较好，基本不用C++自带的vector和string等等，不行吗？

class Solution {
public:
    /*解法一：
        借助n个大小的额外空间，直接利用string从字符串中截取
        这种做法当字符串很长的时候，不就是在浪费空间么，并且sting的扩容就对应着malloc。

    string LeftRotateString(string str, int n) {
        int len = str.length();//长度
        if(len == 0) return "";//空，直接返回
        n = n % len;//对n取余
        str += str;//直接从n指定的地方取，不用反转很多次
        return str.substr(n, len);
    }*/
     /*解法二：
        直接在原字符串中，通过n分割字符串，然后进行3次翻转即可。
        注意需要的防御性编程，这是手写代码必须注意的问题。明白不？
    */
    string LeftRotateString(string str, int n) {
        if(str.empty())//字符串为空，则返回空
            return "";//空则返回空，防御性编程。
        if(n == 0 ||  n == str.length() )//n为0或者长度，则直接返回
            return str;
        if(n > 0 && n < str.length() ){//0 < n < length。则使用三次翻转
            Reverse(str , 0 , n-1);//
            Reverse(str , n , str.length()-1);
            Reverse(str , 0 , str.length()-1);
            return str;
        }else
          return "";
    }
private:
    void Reverse(string &s , int start , int end){
        if(s.empty())
            return;
        while(start < end)//反转string指定的开始和结束位置，通过传引用获取的效果
            swap(s[start++] , s[end--]);
    }
};

5、实现atoi

将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0。
一定要注意边界条件，你知道不？？？明白就好。

class Solution {
public:
   /*
   策略则是遍历一遍字符串即可。
    1、地址有效NULL或空字符串
    2、数据是否上下溢出
    3、有无正负号
    4、错误标志输出
   */
    enum Status{kValid = 0 , kInvalid};
    int g_nStatus = kValid;//全局标志 
    int StrToInt(string str) {
        g_nStatus = kInvalid;
        long long num = 0;//long long 8字节，但是int 4字节，所以千万不能越界，占用4字节 最大为7f-ff-ff-ff 最小为 80-00-00-00
        const char* cstr = str.c_str();//将str转换成c字符串形式，也就是指针指向内存区域。
        if( (cstr != NULL) && (*cstr != '\0') )//1、防御性编程 字符存在且第一个非空，则继续处理
        {
            int minus = 1;//标记字符串符号
            if(*cstr == '-')//第一个为减号
            {
                minus = -1;
                cstr++;//指向下一个字符
            }
            else if(*cstr == '+')//第一个为加号
                cstr++;

            while(*cstr != '\0')//循环处理全部字符
            {
                if(*cstr > '0' && *cstr < '9')//为数字
                {
                    g_nStatus = kValid;//因为是数字，则有效。
                    //2345 =  ( ( (0*10+2) * 10 + 3)*10+4 )*10 + 5 这就是霍顿算法。
                    //这种迭代很聪明
                    num = num * 10 + (*cstr -'0');//字符串转换数字迭代计算
                    cstr++;//指向下一个
                    if( ( (minus > 0) && (num > 0x7FFFFFFF) ) ||
                        ( (minus < 0) && (num < (int)0x80000000) ) )//是否越界？
                    {
                        g_nStatus = kInvalid;//无效，返回0
                        return 0;//无效，则直接返回0
                    }
                }
                else
                {
                    g_nStatus = kInvalid;//中间含有非数字字符串，则标记此无效
                    return 0;
                }
            }
            return (num*minus);
        }
        g_nStatus = kInvalid;//无效，则直接返回0,并且标记无效。
        return 0;
    }
};

5、电话号码包含问题

1、写一个函数找出一个整数数组中，第二大的数
2、写一个在一个字符串(n)中寻找字串(m)第一个位置的函数
3、printf的实现
4、strstr的实现
5、实现一个printf类似功能的函数
6、遍历文本找单词并删掉出现频率最少的单词

有时需要偏执狂
关注
专栏目录
c语言 数据结构实现之字符串
08-30
C语言数据结构实现之字符串 C语言数据结构实现之字符串是指使用C语言来实现字符串数据结构的相关操作。字符串是一种基本的数据结构，广泛应用于计算机科学和信息技术领域。下面将详细介绍C语言数据结构实现之字符串...
第十五章 字符串（三）
Hello World
05-31 874
在十五章的最后展示了一个挺复杂的问题，也是利用到了后缀数组的结构，解决的问题是：如何生成随机文本。因为算法的最终确定是“通过文本内容的前K个字符或单词来判断下一个字符或单词是什么”这个思想来进行的，所以书中说这是一个“具有固定转化概率的有限状态马尔科夫链”，但这个术语究竟是什么意思我还没搞清楚。但是总结说来比较简洁的描述方法就是：生成k阶单词或字符级别的随机文本（马尔科夫链）。     在确
排序算法汇总总结
weixin_34138255的博客
07-17 161
一、插入排序 直接插入排序（Insertion Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。 代码实现： #incl...
查找子字符串个数的标准C函数（要求不含库函数）
maomao4024的专栏
07-29 924
int Count(char *const a,char *const b) {//a为主串，b为子串 char *p=a,*q=b;  int count=0;  while(*p)        {   if ((*p==*q)&&(*q)) //匹配条件             {    p++; q++;      }            else
数据结构——串的定义、初始化、赋值、清空
yyy_zxc的博客
04-08 5536
对于新定义的串，一定要初始化，否则做基本操作时容易出错（指针不为空） 比如赋值时，会判断str.ch是否为空，若非空，则用free函数将其内存空间释放掉 当没有初始化直接调用该函数赋值时，会在if(str.ch) free(str.ch)出错 出错原因：free函数释放的是malloc函数申请的空间 如下图所示，声明变量是会分配地址空间的，此时若直接为s2赋值的话，free(str.ch)会出错，因为此时的s2不是malloc函数申请的空间，是系统自动分配的
数据结构——顺序串（定义初始化、赋值、遍历、两串比较）
qq_51231048的博客
07-16 3766
S;串的组成1length用length记录串的长度是为了减少后期的遍历串获取串长度的时间复杂度。如果不设置length的话，每一次获取字符串长度都需要一次循环，时间复杂度为O(n)，如果设置了length的话，给串新增字符的过程中就记录当前串的长度，未来需要串的长度的时候直接获取length就可以了，时间复杂度降低为O(1)。2chch是串里的字符串。......
头歌数据结构数据结构—字符串
05-18
字符串作为数据结构的一种，广泛应用于各种场景，如文本处理、搜索算法、编程语言等。本文将深入探讨字符串的四个基本操作：子串插入、子串删除、子串定位和子串替换。 首先，子串插入（InsStr）操作允许我们在一个...
数据结构实验——字符串相关操作
05-13
本人本科学习期间数据结构的第三个实验 1、实现串赋值、串比较、求串长、串联接、求子串以及串匹配（KMP算法） 2、能利用上述实现的基本操作完成置换Replace (&S, T, V)以及从串中删除一段子串StrDelete(&S,pos,len)...
C语言数据结构实现字符串分割的实例
12-31
C语言数据结构实现字符串分割的实例 以下为“字符串分割”的简单示例： 1. 用c语言实现的版本 #include<stdio> /* 根据空格分隔字符串 */ int partition(char *src, char *par, int pos) { int i,j; i = pos; ...
数据结构-字符串（C语言
最新发布
weixin_54454406的博客
11-04 289
是由零个或多个字符组成的有限序列，是一种常见的数据结构，用于存储和操作文本数据。它由字符序列组成，字符可以是字母、数字、符号或空格等。在计算机科学和编程中，字符串通常被视为不可变的，这意味着一旦创建了一个字符串，它的内容就不能被更改。这有助于确保字符串的稳定性和一致性。
算法与数据结构（C语言描述） 顺序表两个字符串连接起来
06-10
算法与数据结构（C语言描述） 顺序表两个字符串连接起来，自己手打的，总的来说我感觉算法与数据结构
数据结构 串
12-07
学习课件------ 数据结构--- 串章节---简单明了----大学课件
数据结构——串的基本操作
05-08
c++编写的串的基本操作。（全） cout<<"0-遍历"; cout<<" 1-初始化"; cout<<" 2-串赋值"; cout<<" 3-判串相等"<<endl; cout<<"4-求串长"; cout<<" 5-串连接"; cout<<" 6-求子串"; cout<<" 7-子串定位"<<endl; cout<<" 8-插入子串"; cout<<" 9-删除子串";
【数据结构】串（一）—— 串的基础知识
haoweixl的博客
05-30 4370
【数据结构】串（一）—— 串的基础知识前言一、串类型的定义二、串的三种存储结构存（1）定长顺序存储（2）变长分配存储表示（堆分配）（3）块链存储三种存储结构的总结总结三、串的操作串的初始化（以下基于顺序表）：串的操作（代码）： 前言 C语言字符串与数据结构中的串的区别： C语言中有个字符串，数据结构中有个串，联系是二者都是存储字符的，区别在于前者我们直接定义数组存储，以 “ \0 ”结尾，如 char str[size]; 而后者我们是把字符串看成一个线性表，定义成结构体形式，可以用链表，也可以是顺序表(
数据结构c语言版顺序字符串怎样创建,数据结构（C语言版）---串
weixin_30215717的博客
05-17 488
1、串：由零个或多个字符组成的有限序列，记作S='a1a2a3...an'(n>=0)，其中，S为串名，单引号括起来的字符序列为串的值。1)串中字符的个数n为串的长度，n=0时的串称为空串。2)串相等：两个串的长度相等且每个对应位置的字符都相等。3)空格串：由一个或多个空格组成的串，其长度为串中空格字符的个数。2、串的存储结构1)定长顺序存储(1)截断：超过预定义长度的串值被舍去。(2)串长...
【数据结构基础】-串-顺序结构的基本操作实现
qq_33820545的博客
10-12 825
2019.10.12        数据结构中串的基本操作实现，包括串的定义，串的初始化，赋值，获取串的长度，串的比较，连接串，求子串，清空串。        语言：c语言        运行环境：dev #include <stdio.h> #include&l...
while循环时间间隔
小山半白的博客
05-02 7573
public class Test01 { public static void main(String[] args) { while(true){ try { Thread.currentThread().sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } System.ou...
c语言while(*p *q),C语言经典例题和答案
weixin_39947961的博客
05-21 453
《C语言经典例题和答案》由会员分享，可在线阅读，更多相关《C语言经典例题和答案(18页珍藏版)》请在人人文库网上搜索。1、精选文档作业一一、 求一个任意边长的矩形面积。#include void main()int w,h,sum;scanf(%d%d,&w,&h);sum=w*h;printf(area=%dn,sum);二、 求一个任意半径的圆的面积及周长。#define PI...
C语言数据结构实现之字符串操作详解
C语言数据结构实现之字符串是指使用C语言实现的字符串数据结构，包括字符串的存储结构、基本操作和实现算法。下面将详细介绍C语言数据结构实现之字符串的相关知识点。 **字符串存储结构** 在C语言中，字符串可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

有时需要偏执狂

请我喝咖啡

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

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

打赏作者

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

抵扣说明：

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

余额充值