链式串的复制，连接，子串，插入，删除操作（串篇)

已于 2022-06-30 21:12:16 修改
阅读量7.5k 收藏 70
点赞数 5
分类专栏： 数据结构 文章标签： 数据结构 链表 算法 c++ c语言
于 2021-11-08 22:31:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46104786/article/details/121217904
版权

前言：

上一篇文章，博主写了顺序串的一些简单操作，串和之前我们学过的栈，队列，都是有链式的存储结构，因为顺序的存储总是有限的，而链式的存储是不需要我们定义大小的，要用多少就生成多少，不用就释放掉，确实在存储方面，链式存储有着很大的优点，这篇文章是需要和上一篇文章结合看的，因为里面有许多的逻辑，博主都是说看上一篇文章，哈哈哈偷个懒，接下来让我们来学习吧！！！😁😁😁

每日一遍，要努力！！

20200817629544_bgKxDz

1.理解链式串的逻辑，认识链式串的核心代码

串的链表存储结构与顺序存储结构类似也有紧缩和非紧缩存储结构的区别。插入、删除操作效率高；存储空间的利用率低；

链式串的建立的逻辑图

image-20211108205812441

核心代码：

没什么难的代码，只是一些基础代码，只要链表学的好，看这个没什么问题

typedef struct Node//结构体
{
    char data;            //字符域
    struct Node *next;  //指针域，存放下一个结点的地址
}*LinkString;//指针结构体类型名
LinkString s1;//定义串指针
 s=(LinkString)malloc(sizeof(Node));//分配内存 
 s->next=NULL;//最后一个指向NULL
 q->data=p->data;//串结点之间的赋值
  free(q);//释放结点

2.链式串的初始化和一些基本操作

链式串的最基本的初始化，判断空串，求长度。

LinkString CreateNullString() //链式串初始化操作
{  
    LinkString s;//定义第一个结点 
    s=(LinkString)malloc(sizeof(Node));//分配内存 
    if(s!=NULL) //判断是否分配成功，成功了就把指针域赋值NULL 
        s->next=NULL;
    return s;
}
//判断链式串是否为空串
int iEmpty(LinkString s)//判断链式串s为空串
{
    if(s->next==NULL)//s的指针域为空 
        return 1;
    else
        return 0;
}
//求链式串的长度length
int length(LinkString s)//求链式串的长度
{
    LinkString p;
    int n=0;
    p=s->next;
    while(p!=NULL)//遍历链式串 
    {
        n++;//累加返回 
        p=p->next;//往下位移 
    }
    return n;//返回计数变量的值 
}
//输出操作
void print(LinkString s)//打印输出
{
     LinkString p=s->next;
     while(p!=NULL)
     {
        printf("%c",p->data);
        p=p->next;
     }
     printf("\n");
}

3.链式串的赋值操作

这个赋值操作就相当于单链表的尾插法，不是很难，博主也写了详细的注解

void Stringassign(LinkString s,char t[])//链式串尾插法赋值操作
{
    LinkString p,q,r;
    r=s;        //r始终表示的是尾结点（最后一个非空节点，而不是最后一个NULL节点）。
    q=s->next;
    int i;
    for(i=0;t[i]!='\0';i++)//遍历我们要赋值的数组 
        if(q!=NULL)//判断s的这个这个结点是不是不为空 
        {//初始化时给头结点分配了存储空间或者有其他情况
            q->data=t[i];//赋值直接覆盖 
            r=q;//记录尾结点 
            q=q->next;//指向一个 
        }
        else
        {
            p=(LinkString)malloc(sizeof(Node)); //分配新结点 
            p->data=t[i];//赋值 
            r->next=p;//尾结点连接新结点 
            r=p;//记录新的尾结点 
        }
        r->next=NULL;//最后一个结点指向空 
        while(q!=NULL) //假设s串中并非空串，我们要把s中原来多余的空间释放掉
        {
            p=p->next;//指向下一个 
            free(q);//释放 
            q=p;//把未释放的赋值给q 
        }
}

4.链式串的复制操作

链式串的复制操作逻辑和顺序串的一致，不懂的可以看博主上一篇文章。真的没什么东西逻辑基本一致导致博主连逻辑图都不想画，博主会在下面放上一篇文章

void assign(LinkString s,LinkString t)//链式串复制操作 ，将t串的值复制给s串
{  
    LinkString p,q,r,str;
    p=t->next;
    q=s->next;
    r=s;
    while(p!=NULL) //遍历t串 
    {
        if(q!=NULL)//判断s串是否为空，为空代表s串没有内存了 
        {
            q->data=p->data;//复制 
            r=q;//用来记录s串每次遍历的值 
            q=q->next;//s串往后移 
        }
        else//s串为空需要划分内存给s保存值 
        {
            str=(LinkString)malloc(sizeof(Node));//创建新结点来保存值 
            str->data=p->data;//复制 
            r->next=str;//最后一个连接新的结点 
            r=str;//改变尾指针的指向 
        }
        p=p->next;//t串往后走 
    }
    while(q!=NULL)//如果s串够长，比t串还长就释放 
    {
        p=p->next;
        free(q);//释放多余s的结点 
        q=p;
    }
    r->next=NULL;
}

5.链式串两个串之间的连接

连接的逻辑也是和顺序串一样的，都需要创建一个新的串，然后再连接

image-20211108213329805

//串的连接操作
void contact(LinkString s,LinkString s1,LinkString s2)
{
    LinkString p,q,r,t;
    r=s;
    p=s1->next;
    q=s->next;
    while(p!=NULL)//遍历S1赋值给s 
    {
        if(q!=NULL)//表示s已经分配了结点 ,和复制差不多 
        {
            q->data=p->data; 
            q=q->next;
            r=q;
        }
        else
        {
            t=(LinkString)malloc(sizeof(Node)); //s没有分配内存需要分配 
            t->data=p->data;
            r->next=t;
            r=t;
        }
        p=p->next;
    }
    p=s2->next;//重新赋值p遍历s2 
    while(p!=NULL)//遍历s2赋值 
    {
        if(q!=NULL)//和s1是一样的道理 
        {
            q->data=p->data;
            q=q->next;
            r=q;
        }
        else
        {
            //串s原来没有分配存储空间，需要申请空间
            t=(LinkString)malloc(sizeof(Node));
            t->data=p->data;
            r->next=t;
            r=t;
        }
        p=p->next;
    }
    while(q!=NULL) //遍历将串s的多余的空间清除掉，可能s串很长 
    {
        p=q->next;
        free(q);
        q=p;
    }
    r->next=NULL;   //最后一个指向NULL 
}

6.链式串获取子串操作

用顺序串的图来表示一下逻辑，逻辑是一样的只是，赋值之间不同而已

image-20211107175010158

//截取子串
int substr(LinkString s,int i,int len,LinkString t)
{
    LinkString p,q,r,u;
    if(i<=0 || i>length(s) || i+len-1>length(s) )//判断i和len的有效性
        return 0;
    //指针指向s的第i-1个位置
    int j,k;
    for(j=0,p=s;j<i;j++)//遍历到我们要取子串的位置
        p=p->next;
         
    for(k=0,r=t,q=t->next;k<len;k++)
    {
        if(q!=NULL)//判断t是否划分了内存
        {
            q->data=p->data;//赋值
            r=q;//用来记录在串t没有内存的时候，r代表尾
            q=q->next;
        }
        else
        {
            u=(LinkString)malloc(sizeof(Node));//划分新内存
            u->data=p->data;//赋值
            r->next=u;//连接新结点
            r=u;//改变尾指针的位置
        }
        p=p->next;//s串的位移到下一个
    }
     
    while(q!=NULL)//遍历串t多余的结点，释放
    {  
        p=q->next;
        free(q);
        q=p;
    }
    r->next=NULL;
    return 1;
}

7.链式串的插入操作

梅开二度一下，用单链表的图表示插入操作，真的是一样的逻辑，没什么区别，删除也是一样的逻辑。

image-20211108213001604

//插入操作
int insert(LinkString s,int i,LinkString t)//s代表要被插入的串，i代表在s串的什么位置，t代表要插入进去的值
{
    LinkString p,q,r;
    if(i<=0 || i>length(s)+1)//判断i的有效性
        return 0;
    //指向第i-1个位置
    int j;
    for(j=0,p=s;j<i-1;j++)//遍历s到第i个
        p=p->next;
    q=t->next;
    while(q!=NULL)//遍历t插入串
    {
        r=(LinkString)malloc(sizeof(Node));//分配结点
        r->data=q->data;//保存t串的值，q是指向t的
        r->next=p->next;//新结点指向p的下一个结点建立连接，连接p之后的结点，p代表第i个结点
        p->next=r;//s串中第i个是p，p的下一个是我们的插入结点，形成新的链
        q=q->next;//t串位移到下一个结点
        p=r;//代表位移到新结点的位置，打算插入新的值
 
    }
    return 1;
}

8.链式串的删除操作

//删除操作
int deleteString(LinkString s,int i,int len){//s代表字符串，i表示起始位置，len表示i之后多少个
    LinkString p,q,r;
    if(i<=0 || i>length(s) || i+len-1>length(s) )//和顺序串逻辑一致，可以看博主上一篇文章
        return 0;
    int j;
    for(j=0,p=s;j<i-1;j++)//遍历到我们要删除的位置
        p=p->next;
    for(j=0;j<len;j++)//遍历删除，和链表的删除一致，可以看博主之前的文章
    {
        q=p->next;//记住被删除的上一个位置
        p->next=q->next;//把上一个位置的指针域指向下一个
        free(q);
    }
    return 1;
 
}

9.效果演示和整体代码

image-20211108213937760

整体代码：（可以直接跑）

#include <iostream>
#include<stdio.h>
#include<stdlib.h>
typedef struct Node
{
    char data;            //字符域
    struct Node *next;  //指针域，存放下一个结点的地址
}*LinkString;
LinkString CreateNullString() //链式串初始化操作
{  
    LinkString s;//定义第一个结点 
    s=(LinkString)malloc(sizeof(Node));//分配内存 
    if(s!=NULL) //判断是否分配成功，成功了就把指针域赋值NULL 
        s->next=NULL;
    return s;
}
int iEmpty(LinkString s)//判断链式串s为空串
{
    if(s->next==NULL)//s的指针域为空 
        return 1;
    else
        return 0;
}
void Stringassign(LinkString s,char t[])//链式串尾插法赋值操作
{
    LinkString p,q,r;
    r=s;        //r始终表示的是尾结点（最后一个非空节点，而不是最后一个NULL节点）。
    q=s->next;
    int i;
    for(i=0;t[i]!='\0';i++)//遍历我们要赋值的数组 
        if(q!=NULL)//判断s的这个这个结点是不是不为空 
        {//初始化时给头结点分配了存储空间或者有其他情况
            q->data=t[i];//赋值直接覆盖 
            r=q;//记录尾结点 
            q=q->next;//指向一个 
        }
        else
        {
            p=(LinkString)malloc(sizeof(Node)); //分配新结点 
            p->data=t[i];//赋值 
            r->next=p;//尾结点连接新结点 
            r=p;//记录新的尾结点 
        }
        r->next=NULL;//最后一个结点指向空 
        while(q!=NULL) //假设s串中并非空串，我们要把s中原来多余的空间释放掉
        {
            p=p->next;//指向下一个 
            free(q);//释放 
            q=p;//把未释放的赋值给q 
        }
}
 
void assign(LinkString s,LinkString t)//链式串复制操作 ，将t串的值复制给s串
{  
    LinkString p,q,r,str;
    p=t->next;
    q=s->next;
    r=s;
    while(p!=NULL) //遍历t串 
    {
        if(q!=NULL)//判断s串是否为空，为空代表s串没有内存了 
        {
            q->data=p->data;//复制 
            r=q;//用来记录s串每次遍历的值 
            q=q->next;//s串往后移 
        }
        else//s串为空需要划分内存给s保存值 
        {
            str=(LinkString)malloc(sizeof(Node));//创建新结点来保存值 
            str->data=p->data;//复制 
            r->next=str;//最后一个连接新的结点 
            r=str;//改变尾指针的指向 
        }
        p=p->next;//t串往后走 
    }
    while(q!=NULL)//如果s串够长，比t串还长就释放 
    {
        p=p->next;
        free(q);//释放多余s的结点 
        q=p;
    }
    r->next=NULL;
}
 

int length(LinkString s)//求链式串的长度
{
    LinkString p;
    int n=0;
    p=s->next;
    while(p!=NULL)//遍历链式串 
    {
        n++;//累加返回 
        p=p->next;//往下位移 
    }
    return n;//返回计数变量的值 
}
 
//串的连接操作
void contact(LinkString s,LinkString s1,LinkString s2)
{
    LinkString p,q,r,t;
    r=s;
    p=s1->next;
    q=s->next;
    while(p!=NULL)//遍历S1赋值给s 
    {
        if(q!=NULL)//表示s已经分配了结点 ,和复制差不多 
        {
            q->data=p->data; 
            q=q->next;
            r=q;
        }
        else
        {
            t=(LinkString)malloc(sizeof(Node)); //s没有分配内存需要分配 
            t->data=p->data;
            r->next=t;
            r=t;
        }
        p=p->next;
    }
    p=s2->next;//重新赋值p遍历s2 
    while(p!=NULL)//遍历s2赋值 
    {
        if(q!=NULL)//和s1是一样的道理 
        {
            q->data=p->data;
            q=q->next;
            r=q;
        }
        else
        {
            //串s原来没有分配存储空间，需要申请空间
            t=(LinkString)malloc(sizeof(Node));
            t->data=p->data;
            r->next=t;
            r=t;
        }
        p=p->next;
    }
    while(q!=NULL) //遍历将串s的多余的空间清除掉，可能s串很长 
    {
        p=q->next;
        free(q);
        q=p;
    }
    r->next=NULL;   //最后一个指向NULL 
} 
//截取子串
int substr(LinkString s,int i,int len,LinkString t)
{
    LinkString p,q,r,u;
    if(i<=0 || i>length(s) || i+len-1>length(s) )
        return 0;
    //指针指向s的第i-1个位置
    int j,k;
    for(j=0,p=s;j<i;j++)
        p=p->next;
         
    for(k=0,r=t,q=t->next;k<len;k++)
    {
        if(q!=NULL)
        {
            q->data=p->data;
            r=q;
            q=q->next;
        }
        else
        {
            u=(LinkString)malloc(sizeof(Node));
            u->data=p->data;
            r->next=u;
            r=u;
        }
        p=p->next;
    }
     
    while(q!=NULL)
    {  
        p=q->next;
        free(q);
        q=p;
    }
    r->next=NULL;
    return 1;
}
 
 
//插入操作
int insert(LinkString s,int i,LinkString t)
{
    LinkString p,q,r;
    if(i<=0 || i>length(s)+1)
        return 0;
    //指向第i-1个位置
    int j;
    for(j=0,p=s;j<i-1;j++)
        p=p->next;
    q=t->next;
    while(q!=NULL)
    {
        r=(LinkString)malloc(sizeof(Node));
        r->data=q->data;
        r->next=p->next;
        p->next=r;
        q=q->next;
        p=r;
 
    }
    return 1;
}
 
//删除操作
int deleteString(LinkString s,int i,int len){
    LinkString p,q,r;
    if(i<=0 || i>length(s) || i+len-1>length(s) )
        return 0;
    int j;
    for(j=0,p=s;j<i-1;j++)
        p=p->next;
    for(j=0;j<len;j++)
    {
        q=p->next;
        p->next=q->next;
        free(q);
    }
    return 1;
 
}
 
//打印输出
void print(LinkString s)
{
     LinkString p=s->next;
     while(p!=NULL)
     {
        printf("%c",p->data);
        p=p->next;
     }
     printf("\n");
}
int main(int argc, char** argv) {
	LinkString s1;
    LinkString s2;
    LinkString s3;
    s1=CreateNullString();
    s2=CreateNullString();
    s3=CreateNullString();
    char str[100];
    printf("请输入字符串：\n");
    gets(str);
    Stringassign(s1,str);
    printf("链式串s1：");
    print(s1);
    printf("链式串s1的长度为：%d\n",length(s1));
    assign(s2,s1);
    printf("链式串s2：");
    print(s2);
    printf("链式串s2删除操作(第2个位置的三个字符删除 ：");
    deleteString(s2,2,3);
    print(s2);
    printf("链式串连接操作连接s1和s2生成s3：");
    contact(s3,s1,s2);
    print(s3);
    printf("链式串插入操作(从s1的第6个位置插入s3)：");
    insert(s1,6,s3);
    print(s1);
    printf("链式串截取子串的功能s2（截取s3的第四个位置长度为4的字符串：");
    substr(s3,4,4,s2);
    print(s2);
	return 0;
}

总结：

链式串真的不是很难，都是我们之前学过的东西，换汤不换药，逻辑基本一致，现在博主觉得，线性表存储结构为什么链表要最先学，因为后面的栈，队列，串，基本上是在链表的基础上完成的，不怎么难，没有什么技术上面的问题，接下来，我就要学数组啦，关注后面的文章哦，创作不易点赞，评论，收藏哦！！❤❤❤

上一篇： 数据结构专升本学习，顺序串篇（顺序串的复制，判断相等，连接，子串，查找子串在母串位置，插入，删除）

下一篇：数据结构专升本学习，数组和数组矩阵的三种压缩（画图教你矩阵对称，对角压缩，三角压缩）

20180430093823_WEQaTx

IC00
关注
专栏目录
块链串的插入与删除操作【C语言】
在人间已是颠
12-05 1842
块链串的插入与删除操作【C语言】 题目: __S是用结点大小为4的单链表存储的串，试实现: (1)在第k个字符后插入串T (2)从第k个字符删除len个字符 __ 时间复杂度为任意 空间复杂度为任意 代码: 运行情况: Copyright © 2019 wyq. All rights reserved. ...
【数据结构】CH4 串
最新发布
m0_72318954的博客
10-09 1174
串的介绍
串的基本操作定长顺序存储表示：初始化串、复制串、判断串是否为空、比较两个字符串、计算字符串长度、清空串、连接串、找子串、模式匹配、替换子串、插入和删除子串
06-05
串的基本操作定长顺序存储表示：初始化串、复制串、判断串是否为空、比较两个字符串、计算字符串长度、清空串、连接串、找子串、模式匹配、替换子串、插入和删除子串
串的插入，删除，定位，连接等操作
Jay Chang
06-29 1034
#include&lt;stdlib.h&gt; #include&lt;iostream&gt; #define MAXLEN 20 #define TRUE 1 #define FALSE 0 using namespace std; typedef struct SString{ char ch[MAXLEN]; int len; }SString; ...
[数据结构]链串的copy
zjhzcjg的专栏
11-16 889
 #include iostream>using namespace std;struct StrNode;typedef struct StrNode *PStrNode;struct StrNode{    char c;    PStrNode link;};typedef struct StrNode *LinkString;void  copyStr_link(LinkStrin
顺序串的复制，判断相等，连接，子串，查找子串在母串位置，插入，删除（顺序串篇）
qq_46104786的博客
11-07 6992
前言： 前面我们把栈和队列已经学的差不多了，今天来复习一下，数据结构的串，串的存储结构，在Java里面是有String类型的，但是C语言里面是没有的，需要自己封装一下，再进行操作。串是由零个或多个字符组成的有限序列，串长度为零我们称为空串，它不含任何字符。在学习串我们只要学习，串的算法，例如复制，连接，判断相等，求子串之类的算法。 每日一遍，心情愉悦 （你们应该没有这样的损友吧，????????????） 1.顺序串 顺序串的存储结构的和线性表一样，也是主要分为顺序存储结构和链式存储结构两类，前者简称顺序
C语言数据结构之串插入操作
08-28
串是一种常用的数据结构，串插入操作是串操作中的一种重要操作。下面将详细介绍C语言数据结构之串插入操作的相关知识点。 串的定义 在C语言中，串是一种特殊的数据结构，串是由零个或多个字符组成的序列。串可以...
数据结构 串的操作
09-28
本篇文章将深入探讨数据结构中的串操作。 串，又称为字符串，在许多编程语言中都有专门的表示和操作方式。在C++中，我们有`std::string`类；在Java中，有`String`类；而在Python中，字符串是内置的数据类型。串的...
数据结构： 串
Libra_Ng
10-18 3594
串：字符串简称串，是一种特殊的线性表，它的数据元素仅由一个字符组成；串(String)是由零个或多个字符组成的有限序列，又称字符串；S=&amp;quot;a1,a2,a3…an&amp;quot;其中S是串名,用双引号括起来的字符序列为串值，但引号本身并不属于串的内容。ai(1&amp;amp;lt;=i&amp;amp;lt;=n)是一个任意字符,它称为串的元素,是构成串的基本单位，i是它在整个串中的序号；n为串的长度,表示串中所包含的字符个数. 串的基本...
链串的建立与插入操作
weixin_34336526的博客
04-21 355
为什么80%的码农都做不了架构师？>>> ...
C语言-数据结构-链串插入删除链接
怪咖的博客
05-24 1886
#include #include ///链串插入和删除和连接 ///adc  mn dfe typedef char datatype; typedef struct node {     datatype  data;     struct node *next; }node; typedef node *linkstr; ///创建字符串 void creates
字符串中的删除操作
Bruce Lee的专栏
09-07 1216
1.删除指定字符 该方法是《The C programming language》中的一个例子，写的很巧妙，原地删除，没有多用额外的存储空间。 void squeeze(char *s , int c) { int i , j; for(i = j = 0 ; s[i] ; i++) { if(s[i] != c) s
字符串复制操作
iyy123IUU的博客
02-21 333
#include &lt;stdio.h&gt; #include &lt;string.h &gt; union Data { int i; float f; char str[20]; }; int main( ) { union Data data; data.i = 10; data.f = 220.5; s...
583. 两个字符串的删除操作
zrh_CSDN的博客
01-06 263
给定两个单词 word1 和 word2，找到使得 word1 和 word2 相同所需的最小步数，每步可以删除任意一个字符串中的一个字符。 示例 1: 输入: "sea", "eat" 输出: 2 解释: 第一步将"sea"变为"ea"，第二步将"eat"变为"ea" 说明: 给定单词的长度不超过500。 给定单词中的字符只含有小写字母。 class Solution {
第八周(1) 项目2 - 建立链串的算法库
lt1095862229的博客
10-19 240
链串算法库采用程序的多文件组织形式，包括两个文件： 　　1.头文件：liString.h，包含定义链串数据结构的代码、宏定义、要实现算法的函数的声明； #ifndef LISTRING_H_INCLUDED #define LISTRING_H_INCLUDED typedef struct snode { char data; struct snode *next;
【数据结构】顺序串的插入算法，删除算法，连接运算，顺序串求子串算法
( :3 )
12-18 9798
主函数自行添加 头文件 + 宏定义 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define MAXSIZE 100 串的顺序存储 typedef struct { char str[MAXSIZE]; int length; }seqstring; 顺序串的创建 void creat(seqstring *S) {...
数据结构 ------链式串的基本操作
玩转Java
03-26 2368
数据结构 ------链式串的基本操作： 这里采用串的链式存储结构，在明白了单链表的基本原理基础上，再理解串的链式存储以及相关操作就通俗易懂了。 这里要注意的是，p->next：指向第一个字符，刚开始创建的p为头结点，然后需要注意的地方就是这里的 r->next =q; r =q; 这里的意思是将q指针放在r->next的后面，接着r指针移动q指针的位置. 还有一种就是（q->next =r->next，r->next =q;)主要注意 q->next = r-&
串插入
wei_sj的博客
12-23 1332
//链串中串插入运算 #include #include typedef struct snode { char data; struct snode *next; }LiString; //链串节点类型 void StrAssingn(LiString **s, char str[]) //尾插法建立链串 { LiString *p,
串操作
阳光日志
03-06 4737
概述 字符串的应用已经非常广泛，如信息检索、文字编辑、自然语言的翻译等都离不开字符串。在各种高级语言的程序设计中都会有字符串类型，虽然各种语言的表现方式各自不同，但其实现原理基本相同。熟悉java语言的人定会感受到String类的强大和实用性，但是其是如何实现的呢？这就是下面所要讲的内容。 从逻辑关系上来看，串是一各特殊的线性表。它与一般线性表的区别是：一般线性表的操作通常以表内的数据元素
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

IC00

打赏就发新文

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

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

打赏作者

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

抵扣说明：

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

余额充值