C语言递归和非递归实现字符串反转函数char *reverse(char *str)

最新推荐文章于 2022-05-03 22:41:11 发布
最新推荐文章于 2022-05-03 22:41:11 发布
阅读量1w 收藏 9
点赞数 2
CC 4.0 BY-SA版权
分类专栏： C/C++ 文章标签： 语言 c null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ameyume/article/details/5599139
本文介绍了两种字符串反转的方法：一种是使用递归方式实现；另一种是非递归的迭代方式。递归方法通过不断调用自身来逐层反转字符串，而非递归方法则通过简单的循环和字符交换完成反转。

编写一个函数 reverse_string(char* string) 递归实现 字符串反向排序
昵称就是昵称吧的博客
04-02 2558
编写一个函数 reverse_string(char* string)（递归实现） 实现：将参数字符串中的字符反向排列 要求：不能使用C函数库中的字符串操作函数。 方法一： 逆序打印，通过递归找到'\0'前一个字符，然后依次从后往前打印字符 void reverse_string(char* string) { if (*string != '\0')//当指针string指向'\0'时，不再递归 { string++; reverse_string(string); .
使用C语言递归与非递归实现字符串反转函数char *reverse(char *str)的方法
09-05
本篇文章是对使用C语言递归与非递归实现字符串反转函数char *reverse(char *str)进行了详细的分析介绍，需要的朋友参考下
递归实现字符串反转char* reverse(char* str)合集
a65783305的博客
09-28 337
先看到的是一个递归输出的，不满足要求 void ret_str(char* s){ if(*s != '/0') { ret_str(s+1); }cout<<*s;} 找到的比较好的两种方法，没有static变量，线程安全 char* reverse(char* str){ int len = strlen(str); c...
写一个函数reverse( char s[])，将字符串s[]中的字符串倒序输出。试分别用递归和非递归两种形式编写。
c++爱好者
11-06 3489
题目： 写一个函数reverse( char s[])，将字符串s[]中的字符串倒序输出。试分别用递归和非递归两种形式编写。 代码内容： /*写一个函数reverse( char s[])，将字符串s[]中的字符串倒序输出。 试分别用递归和非递归两种形式编写。 */ //觉得不错点个赞谢谢！ #include<stdio.h> #include<string.h> #define N 20 void reverse_01(char *s) { int i=0; while
宇龙酷派笔试题：求出数组的倒置，函数原型为char * reverse( char * str)
帅的数说
10-16 1447
char *reverse(char *str) { int i,j,n; char temp; i=0; while(str[i]!='\0') { i++; } n=i-1; for(j=0;j { temp=str[j]; str[j]=str[n]; str[n]=temp; n--; }     return str; } 题目中没有说明字符数组st
实现字符串逆序（递归和非递归）
zjybp的博客
11-13 753
●字符串逆序 通过指针分别指向字符串的首和尾进行操作 void reserve(char *str) { char* left=str; char* right=str+strlen(str)-1; while(left<right) { char temp=*left; *left=*right; *right=temp; left++; right--; } } int main() { char arr[]="asdfqwerj";
字符串逆序-使用C语言+递归实现字符串逆序.zip
03-21
4. 将原始字符串的第一个字符与逆序的剩余部分拼接起来，这可以通过在逆序部分的末尾添加第一个字符实现。 以下是一个简单的C语言代码示例： ```c #include #include void reverse(char* str, int len) { if ...
使用递归算法来实现字符串逆序-C语言实现.zip
03-21
本教程主要探讨如何使用C语言中的递归算法实现字符串逆序。首先，我们需要理解递归的基本概念，然后深入到C语言中如何操作字符串，最后将递归应用于这个特定问题。 **递归定义** 递归是函数或程序设计的一种技术，...
C语言： 编写一个函数reverse_string(char * string)（递归实现 ：将参数字符串中的字符反向排列。）
qq_42270373的博客
07-30 1221
题目： 编写一个函数reverse_string(char * string)（递归实现：将参数字符串中的字符反向排列。） 要求：不能使用C函数库中 的字符串操作函数。 方法1： #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;assert.h&gt; char* reverse_string(char *st...
编写一个函数 reverse_string(char * string)（递归实现） 实现：将参数字符串中的字符反向排列。 要求：不能使用C函数库中的字符串操作函数。
Hello-三哥哥
04-07 281
程序代码: #include <stdio.h> #include <string.h> void reverse_string(char * str) { int len = strlen(str) - 1; char tmp; if (str[0] == '\0') { return; } tmp = str[0]; str[0] = str[l...
C和指针 第六章 6.3 reverse_str(char *str)
xiaoyuanqq666的专栏
05-09 372
#include void reverse_str(char *str);/********反转字符串**********/{char *cp=str;int i=0;while(*str!='/0'){  str++;i++;}i/=2;str--;while(i-->0){  *str^=*cp;*cp^=*str;*str^=*cpstr--;cp++;}}void main(){char str[]="ABCDEFG";printf("str is : %s",str);reverse_str(st
编写一个函数 reverse_string(char * string)，将参数字符串中的字符反向排列
melody_1016的博客
10-18 2988
题目：编写一个函数 reverse_string(char * string)，将参数字符串中的字符反向排列 思路：设置两个指针，分别指向字符串的头部和尾部，两两交换；然后另两个指针都向中间移动，每次移动都交换元素，直到指针相遇。图解如下： 代码： #define _CRT_SECURE_NO_WARNINGS 1 #include&lt;stdio.h&gt; #include&lt...
C语言初阶习题（3函数）【16】字符串逆序（递归和非递归实现）
graceyun的博客
09-05 312
字符串逆序（递归实现） 题目内容 编写一个函数 reverse_string(char * string)（递归实现） 实现：将参数字符串中的字符反向排列，不是逆序打印。 要求：不能使用C函数库中的字符串操作函数。 比如: char arr[] = “abcdef”; 逆序之后数组的内容变成：fedcba 题目分析 逆序打印：字符串本身不变，你反着输出即可 反向排列：修改字符串的本身，把自妇产给倒过来 不用递归实现 先创建一个 left= 0； 在创建一个right = size-1； 交换 left 和
字符串逆序（非递归和递归实现）
m0_68071216的博客
05-03 850
编写一个函数 reverse_string(char * string)（递归实现） 实现：将参数字符串中的字符反向排列，不是逆序打印。 要求：不能使用C函数库中的字符串操作函数。 非递归实现： 非函数实现： #include<stdio.h> int main() { char arr[] = "abcdefg"; int sz = sizeof(arr) / sizeof(arr[0]); //sizeof计算时，认为arr里放的是{a b c d e f g \0
字符串反转（reverse函数）
JasonChen_ACM的博客
07-25 4172
猜一下下面函数的功能：char *strrev(char *str) { char *p1, *p2; if (! str || ! *str) return str; for (p1 = str, p2 = str + strlen(str) - 1; p2 > p1; ++p1, --p2) {
编写一个函数 reverse_string(char * string)（递归实现）
Lee's site
05-23 349
实现接口代码： //判断字符串第一位是否为 \0 如果不是，将指针加1，指向下一个字母，以此类推，如果下一个是 \0 那么就返回指针所指向的字符 void reverse_string(char *string){ if (*string != '\0') reverse_string(string+1); printf("%c", *(string)); } ...
倒置函数reverse的用法
一只叫做Unix的猫
01-18 3677
http://blog.sina.com.cn/s/blog_a3cc698201018czr.html 倒置字符串函数reverse：用于倒置字符串s中的各个字符的位置，如原来字符串中如果初始值为123456，则通过reverse函数可将其倒置为654321，程序如下： #include #include void reverse(char s[]) {    int c,j
c语言 -字符串逆序（全解析）（递归和非递归）
weixin_51136573的博客
11-09 1404
字符串逆序 题目： 写一个函数，可以逆序一个字符串的内容。 解析： 我们可以将字符串两边的字符逐个交换。 设置两个指针，分别指向字符串的头部和尾部，然后交换两个指针所指的字符，并向中间移动指针，当左边大于右边时结束交换。 例： 字符串"abcdef"，逆序的过程分别是交换字符a和f，交换字符b和e，交换字符c和d。 递归代码： #include<stdio.h> #pragma warning(disable:4996) #include<Windows.h> void Reve
实现函数void reverse_string(char*str)，原地反转字符串
最新发布
04-18
<think>好的，我需要帮助用户实现一个原地反转字符串的C语言函数void reverse_string(char* str)。首先，用户提到要原地反转，所以不能使用额外的数组，必须直接在原字符串上进行操作。我需要回忆一下常见的反转字符串的方法。 通常，反转字符串可以通过双指针法，一个指针从头部开始，另一个从尾部开始，逐步交换字符，直到两个指针相遇。不过用户提供的引用中提到了递归的方法，比如引用[1]中的逆序打印，但那是通过递归打印实现的，并不修改原字符串。而引用[2]中的代码虽然使用递归，但通过交换首尾字符并递归处理子字符串，实现了原地反转。不过用户现在需要的是函数void reverse_string(char* str)，所以可能需要参考引用中的递归方法，或者使用更常见的迭代方法。 首先考虑迭代方法。迭代的话，步骤应该是找到字符串的长度，然后设置头尾指针进行交换。例如，计算字符串长度n，然后从0到(n-1)/2的位置交换str[i]和str[n-1-i]。需要注意的是，C字符串以'\0'结尾，所以长度可以通过strlen获取，但需要确保字符串是可修改的，比如字符数组而不是字符串常量。 接下来考虑递归方法。递归的思路可能类似于引用[2]中的代码：每次递归交换首尾字符，然后处理中间的子字符串。例如，取出首字符，将尾字符放到首部，中间部分递归处理，最后把原首字符放到尾部。同时，每次递归需要处理子字符串，即在交换首尾后，将字符串中间的部分递归处理。需要注意的是，递归的终止条件应该是当子字符串长度小于等于1时停止。 不过，递归方法可能会有栈溢出的风险，尤其是长字符串的情况下，但用户可能想了解不同的实现方式。所以，我应该提供两种方法：迭代和递归，并解释它们的优缺点。 现在需要验证这两种方法的正确性。对于迭代法，例如字符串"hello"，长度是5，交换索引0和4，1和3，得到"olleh"。对于递归法，比如引用[2]中的例子，处理"abc"时，第一次交换a和c，变成"cba"，然后处理中间的子字符串"b"，此时子字符串长度为1，停止，最终结果为"cba"。不过引用[2]的代码可能有问题，比如在处理字符串长度时，每次递归都计算strlen(p)，可能在递归过程中修改字符串导致问题？比如，原代码中将尾部字符暂存为a，然后交换首尾，接着将尾部设置为'\0'，递归处理子串，之后恢复尾部字符。这种方法可能有效，但需要注意递归中的字符串处理是否正确。 另外，用户需要的是原地反转，所以无论是迭代还是递归都应该满足这一点。现在需要编写正确的代码。 首先，迭代方法的实现步骤： 1. 计算字符串长度，使用strlen。 2. 使用两个指针，一个指向开头，一个指向末尾。 3. 循环交换字符，直到指针相遇。 例如： void reverse_string(char* str) { if (str == NULL) return; int len = strlen(str); for (int i = 0; i < len / 2; i++) { char temp = str[i]; str[i] = str[len - 1 - i]; str[len - 1 - i] = temp; } } 这应该可以工作，并且是原地操作。 然后是递归方法，参考引用[2]，但需要调整可能的问题。递归的步骤： 1. 交换首尾字符。 2. 对中间的子字符串进行递归处理。 3. 需要确保每次递归处理的是去掉首尾后的子串，并且保持字符串以'\0'结尾？或者可能不需要，因为每次递归处理的子字符串长度减少。 例如，递归函数可能像这样： void reverse_string(char* str) { int len = strlen(str); if (len <= 1) return; // 交换首尾字符 char temp = str[0]; str[0] = str[len - 1]; str[len - 1] = temp; // 递归处理中间部分 if (len >= 2) { str[len - 1] = '\0'; // 临时截断，以便处理中间部分 reverse_string(str + 1); str[len - 1] = temp; // 恢复尾部字符 } } 但这样可能在处理中间部分时，把原尾部字符暂时设为'\0'，递归处理之后恢复。例如，原字符串是"abcde"，第一次交换首尾得到"ebcda"，然后中间部分"bcd"，长度4，交换首尾得到"edcba"，再处理中间的"cd"，交换得到"edcba"，可能有问题。可能需要调整步骤。 或者，另一种递归方式：每次将当前首字符和剩余部分的反转合并。例如，reverse_string(str) = 反转剩余部分 + 首字符。但这种方法可能需要额外空间，无法原地操作，所以可能不适用。 所以正确的递归方法可能需要像引用[2]中的方法，每次交换首尾，然后递归处理中间的字符串，但需要注意中间字符串的处理。例如： void reverse_string(char* str) { int len = strlen(str); if (len <= 1) { return; } // 交换首尾字符 char temp = str[0]; str[0] = str[len - 1]; str[len - 1] = temp; // 处理中间部分 str[len - 1] = '\0'; // 截断最后一个字符，以便递归处理中间部分 reverse_string(str + 1); str[len - 1] = temp; // 恢复最后一个字符 } 这样，例如字符串"abcd"第一次交换首尾为"dbca"，然后截断最后一个字符，变成"dbc"，递归处理"bc"部分，交换得到"cb"，然后截断最后一个字符，变成"c"，递归返回，恢复最后一个字符为"b"，所以得到"cbd"，然后恢复原最后一个字符为"a"，得到"dcba"。这可能有问题，可能需要更仔细的步骤分析。 例如，原字符串是"abcd"，len=4： 第一次交换首尾：a和d交换，得到"dbca"。然后将最后一个字符（原位置3）设为'\0'，现在字符串变为"dbc"，然后递归处理str+1，即"bc"。 在处理"bc"时，交换首尾得到"cb"，然后截断最后一个字符，变成"c"，递归处理str+1（即空字符串），返回。恢复最后一个字符为'b'，此时字符串是"cb"，所以处理后变成"bc"。这可能不正确。 似乎这个方法有问题。可能递归处理的方式需要调整。 或许正确的递归方法应该是在交换首尾之后，处理中间的字符串，不包括已经处理过的首尾。比如，在交换首尾之后，中间的子字符串是str+1到len-2的位置。例如，原字符串是"abcde"，交换首尾后，处理中间的"bcd"，也就是str+1到倒数第二个字符的位置。这时候，递归处理str+1，但需要确保子字符串的长度正确。但这样可能需要调整字符串的结束符，或者在递归时不依赖结束符，而是传递长度，但C语言字符串通常以'\0'结尾，所以可能需要修改临时结束符。 或者，更好的方法可能是计算长度，每次处理子字符串的长度减2，首尾各减少一个。例如： void reverse_string_helper(char* str, int start, int end) { if (start >= end) return; char temp = str[start]; str[start] = str[end]; str[end] = temp; reverse_string_helper(str, start + 1, end - 1); } void reverse_string(char* str) { int len = strlen(str); reverse_string_helper(str, 0, len - 1); } 这样，递归辅助函数处理索引start到end的部分，每次交换首尾，然后递归处理中间部分。这种方法不需要修改字符串的结束符，直接通过索引控制。这可能更可靠。但用户需要的是函数签名void reverse_string(char* str)，所以辅助函数可能不适用，除非在reverse_string内部处理。 不过，用户可能希望一个不需要辅助函数的递归实现。例如： void reverse_string(char* str) { int len = strlen(str); if (len <= 1) return; // 交换首尾 char temp = str[0]; str[0] = str[len - 1]; str[len - 1] = temp; // 处理中间部分，即str+1到len-2的位置 // 将中间部分视为新的字符串，长度是len-2 // 如何递归处理这部分？ // 需要将str+1的位置作为新字符串，并且新字符串的末尾应该是原len-2的位置 // 但C字符串以'\0'结尾，所以可以将原末尾字符保存，设为'\0'，处理后再恢复 str[len - 1] = '\0'; reverse_string(str + 1); str[len - 1] = temp; } 这样，例如处理"abcd"，第一次交换首尾得到"dbca"，然后将最后一个字符设为'\0'，字符串变为"dbc"，递归处理"bc"。在处理"bc"时，交换首尾得到"cb"，设为'\0'，字符串变为"c"，递归返回，恢复最后一个字符为'b'，得到"c b"，但此时原字符串的末尾是temp保存的原来的首字符。这可能需要更仔细的模拟。 以"abcd"为例： 初始调用：str指向"abcd"，len=4. 交换首尾：str[0]和str[3]交换，得到"dbca". 将str[3]设为'\0'，现在字符串是"dbc". 递归调用reverse_string(str+1)即处理"bc". 在处理"bc"时，len=2. 交换首尾得到"cb". 将str[1]设为'\0'，字符串变为"c". 递归调用reverse_string(str+1)即处理空字符串，返回. 恢复str[1]为原来的str[0]（即'b'），所以字符串变为"cb". 回到上一层递归，恢复str[3]为原来的首字符（即 'a'），此时整个字符串是"cba\0a"？ 因为原字符串在交换后是"dbca"，然后将str[3]设为'\0'变为"dbc"，处理完后恢复str[3]为'temp'，即原来的首字符 'd'，所以最终字符串变成"dbcd"？ 这显然有问题。 这说明这个方法可能在处理中间步骤时出现错误，导致最终结果不正确。比如，当处理"abcd"时，可能期望得到"dcba"，但实际结果可能不是这样。 这说明递归方法需要更仔细的处理。可能引用[2]中的方法存在错误，或者需要调整。例如，原引用中的代码： void reverse_string(char* p) { char a = *p; *p = *(p + strlen(p) - 1); *(p + strlen(p) - 1) = a; char b = *(p + strlen(p) - 1); *(p + strlen(p) - 1) = '\0'; if (p < p + strlen(p) - 1) reverse_string(p + 1); *(p + strlen(p) - 1) = b; } 这段代码可能存在问题，因为在递归调用后，strlen(p)会变化，因为中间步骤设置了'\0'。例如，在处理递归时，strlen(p)会计算到第一个'\0'的位置，这可能导致计算错误。 例如，原字符串是"abc"，调用reverse_string(s)，其中s是字符数组。 第一次调用p指向"abc"，len=3. 交换*p（'a'）和p+2（'c'），得到"cba". 然后保存*(p+2)即 'a'到b. 将p+2位置设为'\0'，此时字符串是"cb". 条件p < p + strlen(p) -1：此时strlen(p)是2，所以p + strlen(p)-1是p+1。所以比较p < p+1，成立，递归调用reverse_string(p+1)，即处理"b". 在递归调用中，p指向"b"，len=1，直接返回。 然后恢复p+strlen(p)-1位置为b，即原保存的 'a'. 此时，p是原p+1，即指向原字符串的第二个字符的位置，即当前字符串是"b"，所以strlen(p)是1，p + strlen(p)-1是p，所以恢复p的位置为b，即 'a'。所以此时原字符串变为"c a a"？ 不确定，可能需要实际运行测试。 看起来这种方法可能存在逻辑错误，导致结果不正确。例如，原例子中的输出是否正确？ 用户提供的引用[2]中的代码执行如下： main函数中的s是"abc"（字符数组，可以修改），打印后调用reverse_string(s)，再打印结果。根据代码，原s是"abc"，交换首尾变成"cba"，然后在递归处理中间部分时可能出问题。但根据用户提供的示例输出，最终结果是"cba"吗？ 但原代码执行后，假设正确的话，输出应该是"cba"。可能这个递归方法在特定情况下有效，但存在潜在问题，比如当字符串长度为偶数时？ 所以，可能递归方法虽然能工作，但需要注意处理字符串的截断和恢复步骤，否则容易出错。因此，可能更推荐使用迭代方法，因为更直观且效率更高，没有栈溢出的风险。 综上，用户需要原地反转字符串的函数，正确的实现应该是迭代方法，或者正确实现的递归方法。根据用户提供的引用，引用[2]中的递归方法可能存在潜在问题，但可能可以工作。因此，在回答中，我应该提供两种方法，并指出它们的区别和注意事项。 现在，编写迭代版本的代码： void reverse_string(char* str) { if (str == NULL) return; // 处理空指针 int len = strlen(str); int i = 0; int j = len - 1; while (i < j) { char temp = str[i]; str[i] = str[j]; str[j] = temp; i++; j--; } } 这个方法是标准的双指针交换，时间复杂度O(n)，空间复杂度O(1)，效率高，且容易理解。 然后是递归版本，需要确保正确性。可能正确的递归方法如下： void reverse_string(char* str) { int len = strlen(str); if (len <= 1) { return; } // 交换首尾字符 char temp = str[0]; str[0] = str[len - 1]; str[len - 1] = temp; // 截断最后一个字符，处理中间部分 str[len - 1] = '\0'; reverse_string(str + 1); // 恢复最后一个字符 str[len - 1] = temp; } 测试这个函数： 比如，输入字符串是"abcd"，初始交换首尾得到"dbca"，截断为"dbc"，递归处理"bc"。在递归调用中，交换首尾得到"cbc"，然后截断为"c"，递归处理空字符串，恢复最后一个字符为 'b'，得到"cb"。回到上一层，恢复原截断的字符为 'a'，所以此时字符串变为"dcba"。这似乎正确。 例如，处理"abcd"： 初始str指向"abcd"，len=4. 交换首尾：str[0] = 'd', str[3] = 'a' → "dbca". 截断str[3]为'\0' → 字符串变为"dbc". 递归调用reverse_string(str+1)即处理"bc". 在处理"bc"时，len=2. 交换首尾得到"cb"，截断最后一个字符 → str[1] = '\0'，字符串变为"c". 递归调用reverse_string(str+1)处理空字符串，返回. 恢复str[1] = 'b' → 字符串变为"cb". 返回到上一层，此时str是原str+1的位置，即原字符串的第二个字符的位置，此时恢复str[len-1]（len在此时是2，所以str[1] = temp（原来的首字符 'b'）） → 字符串变为"cb". 回到初始调用，恢复原str[3]为 'a' → 字符串变为"dcba". 所以，最终结果是正确的。 这说明递归方法在这种情况下是正确的。但需要注意，这种方法会修改字符串的结束符，并在递归调用后恢复。这可能在某些情况下导致问题，例如，如果字符串中间原本有其他'\0'，但根据C字符串的定义，这种情况不存在，因为字符串以第一个'\0'结束。因此，该递归方法在正常情况（字符串没有中间'\0'）下是有效的。 因此，在回答中，应该提供这两种方法，并说明它们的实现原理及注意事项。同时，需要提醒用户，递归方法由于多次调用strlen和递归深度，可能在处理长字符串时效率较低或导致栈溢出，而迭代方法更高效。 最后，用户提供的引用[2]中的代码可能正确，但需要仔细验证。在回答中，可以引用该代码作为递归实现的例子，但更推荐迭代方法。</think>### 原地反转字符串函数实现 在C语言中，原地反转字符串的核心思路是通过交换字符位置实现反转，无需额外内存空间。以下是两种实现方法： --- #### **方法一：迭代法（推荐）** 通过双指针从字符串两端向中间遍历，逐步交换字符： ```c #include <string.h> void reverse_string(char* str) { if (str == NULL) return; // 处理空指针 int len = strlen(str); int left = 0; int right = len - 1; while (left < right) { // 交换字符 char temp = str[left]; str[left] = str[right]; str[right] = temp; left++; right--; } } ``` **示例**： 输入`"abcdef"` → 输出`"fedcba"` **优点**：时间复杂度为$O(n)$，空间复杂度为$O(1)$，效率高且稳定[^1]。 --- #### **方法二：递归法** 通过递归逐层交换首尾字符并处理子字符串： ```c #include <string.h> void reverse_string(char* str) { int len = strlen(str); if (len <= 1) return; // 递归终止条件 // 交换首尾字符 char temp = str[0]; str[0] = str[len - 1]; str[len - 1] = temp; // 截断末尾字符，递归处理中间部分 str[len - 1] = '\0'; reverse_string(str + 1); str[len - 1] = temp; // 恢复末尾字符 } ``` **示例**： 输入`"abc"` → 输出`"cba` **注意**：递归深度与字符串长度相关，长字符串可能导致栈溢出[^2]。 --- ### **关键区别** | 方法 | 时间复杂度 | 空间复杂度 | 适用场景 | |--------|------------|------------|------------------| | 迭代法 | $O(n)$ | $O(1)$ | 通用场景，高效 | | 递归法 | $O(n)$ | $O(n)$ | 短字符串，教学示例 | ---
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值