数据结构第二章-线性表

最新推荐文章于 2022-10-07 20:18:00 发布
最新推荐文章于 2022-10-07 20:18:00 发布
阅读量194 收藏 2
点赞数
文章标签： 数据结构 c++ c语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Marsbupt/article/details/126219688
版权

第2章 : 线性表

1 顺序表的实现–静态分配

1.1 顺序表的实现–静态分配

#define MaxSize 10 //定义最大长度
typedef struct{
    ElemType data[MaxSize]; //用静态的“数组”存放数据元素
    int length;             //顺序表的当前长度
}Sqlist;                    //数据表的类型定义（静态分配方式）

初始化一个顺序表

#include<stdio.h>
#define MaxSize 10 //定义最大长度
typedef struct{
    int data[MaxSize]; //用静态的“数组”存放数据元素
    int length;             //顺序表的当前长度
}Sqlist;                    //数据表的类型定义（静态分配方式）

//基本操作
void Initlist(Sqlist &L){
    for (int i = 0;i < MaxSize;i++){
        L.data[i] = 0;
        L.length = 0;
    }
}
int main(){
    Sqlist L;  //声明一个顺序表
    Initlist(L); //初始化顺序表
    for(int i = 0;i < MaxSize;i++){
        printf("data[%d]=%d\n",i,L.data[i]);
    }
    return 0;
}

1.2 顺序表的实现–动态分配

先让p和data指向同一片存储空间，然后用L.data开辟一块新空间，最后把p的数据复制到新区域，最后释放p指针

#include<stdio.h>
#include<stdlib.h>
#define InitSize 10 //定义最大长度
typedef struct{
    int *data;         //指示动态分配数组的指针
    int MaxSize;        //顺序表的最大容量
    int length;             //顺序表的当前长度
}Seqlist;                    //数据表的类型定义（动态分配方式）

//基本操作
void Initlist(Seqlist &L){
    L.data = (int *)malloc(InitSize*sizeof(int));
    L.length = 0;
    L.MaxSize = InitSize;
}
//增加动态数组的长度
void IncreaseSize(Seqlist &L,int len){
    int *p = L.data;   
    L.data = (int *)malloc((L.MaxSize+len)*sizeof(int));
    for(int i= 0 ;i <L.length;i++){
        L.data[i] = p[i]; //将数据复制到新区域
    }
    L.MaxSize = L.MaxSize + len;
    free(p);
}
int main(){
    Seqlist L;  //声明一个顺序表
    Initlist(L); //初始化顺序表
    IncreaseSize(L,5);
    return 0;
}

1.3 顺序表的基本操作–插入

#include<stdio.h>
#define MaxSize 10 //定义最大长度
typedef struct{
    int data[MaxSize]; //用静态的“数组”存放数据元素
    int length;             //顺序表的当前长度
}Sqlist;                    //数据表的类型定义（静态分配方式）

//基本操作
void Listinit(Sqlist &L.int i,int e){
    for (int j = L.length;j>=i;j--){ //将第i个元素及之后的元素后移
      	L.data[j] = L.data[j-1]; 
    }
    L.data[i-1] = e;  //在位置i处放e
    L.length++;   //长度加1
}
int main(){
    Sqlist L;  //声明一个顺序表
    Initlist(L); //初始化顺序表
    ListInsert(L,3,3);
    return 0;
}

1.4 顺序表的基本操作–删除

bool ListDelete(SqList &L,int i,int &e){
  if(i<1||i>L.length)
    return false;
  e = L.data[i-1];
  for(int j = i;j < L.length;j++)
    L.data[j-1] = L.data[j];
  L.length--;
  return true;
}

int main(void){
  Sqlist L;
  InitList(L);
  int e = -1;
  if(ListDelete(L,3,e))
    printf("已删除第三个元素，删除元素值为=%d\n",e);
  else
    printf("位序i不合法，删除失败\n");
  return 0;
}

1.5 顺序表的按值查找

#include<stdio.h>
#include<stdlib.h>
#define InitSize 10 //定义最大长度
typedef struct{
    int *data;         //指示动态分配数组的指针
    int MaxSize;        //顺序表的最大容量
    int length;             //顺序表的当前长度
}Seqlist;                    //数据表的类型定义（动态分配方式）

int LocateElem(Seqlist L,int e){
  for(int i = 0;i <L.length;i++)
    if(L.data[i] == e)
      return i+1; //数组下标为i的元素值为e，返回其位序i+1
  return 0;
}

注意，在c语言中不能直接用==来直接判断两个结构体是否相等，要分别比较其元素

2 链表

2.1 单链表的定义

typedef struct LNode
{
    ElemType data; //数据域
    struct LNode *next; //指针域
}LNode,*LinkList; //*LinkList是指向struct LNode的指针

要声明单链表时，只需声明一个头指针L，指向单链表的第一个节点
LNode *L;
或者 LinkList L;
struct LNode *p = (struct LNode*)malloc(sizeof(struct LNode));

LNode *强调返回的是一个结点，LinkList强调这是一个单链表

LNode * GetElem(LinkList L,int i){
	int j = 1;
	if(i == 0)
		return L;
	if(i < 1)
		return NULL;
	while(p!=NULL && j < i){
		p = p->next;
		j++;
	}
	return p;
}
2.1.1 不带头结点的单链表
typedef struct LNode
{
    ElemType data; //数据域
    struct LNode *next; //指针域
}LNode ,*LinkList; //*LinkList是指向struct LNode的指针

bool InitList(LinkList &L){
		L = NULL;
		return true;
}

void test(){
		LinkList L;
		InitList(L);
}
2.1.2 带头结点的单链表
typedef struct LNode
{
    ElemType data; //数据域
    struct LNode *next; //指针域
}LNode ,*LinkList; //*LinkList是指向struct LNode的指针

bool InitList(LinkList &L){
		L = (LNode *) malloc(sizeof(LNode)); //分配一个头结点
  	if(L == NULL)
      	return false;
  	L->next = NULL;
		return true;
}

void test(){
		LinkList L;
		InitList(L);
}

2.2 单链表的插入删除

2.2.1 按位序插入
在第i个位置插入元素e（带头结点）
#include <stdlib.h>
typedef int ElemType;
typedef struct LNode
{
    ElemType data;
    struct LNode *next;  
}LNode, *LinkList;

bool ListInsert(LinkList &L,int i,ElemType e){
    if(i < 1)
        return false;
    LNode *p;    //指针p指向当前扫描到的结点
    int j = 0;   //当前p指向的是第几个结点
    p = L;       //L指向头结点，头结点是第0个结点（不存数据）
    while(p != NULL && j < i-1){  //循环找到第i-1个结点
        p = p->next;
        j++;
    }
    if(p == NULL)
        return false;
    LNode *s = (LNode *) malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true; //插入成功
}
不带头结点
#include <stdlib.h>
typedef int ElemType;
typedef struct LNode
{
    ElemType data;
    struct LNode *next;  
}LNode, *LinkList;

bool ListInsert(LinkList &L,int i,ElemType e){
    if(i < 1)
        return false;
  	if(i == 1){
      LNode *s = (LNode *)malloc(sizeof(LNode));
      s->data = e;
      s->next = L;
      L = s;
      return true;
    }
    LNode *p;    //指针p指向当前扫描到的结点
    int j = 1;   //当前p指向的是第几个结点
    p = L;       //L指向头结点，头结点是第0个结点（不存数据）
    while(p != NULL && j < i-1){  //循环找到第i-1个结点
        p = p->next;
        j++;
    }
    return InsertNextNode(p,e);
}
bool InsertNextNode(LNode *p,ElemType e){
if(p == NULL)
        return false;
    LNode *s = (LNode *) malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true; //插入成功
}
2.2.2 后插操作
bool InsertNextNode(LNode *p,ElemType e){
    if(i < 1)
        return false;
    LNode *p;    //指针p指向当前扫描到的结点
    int j = 0;   //当前p指向的是第几个结点
    p = L;       //L指向头结点，头结点是第0个结点（不存数据）
    while(p != NULL && j < i-1){  //循环找到第i-1个结点
        p = p->next;
        j++;
    }
    if(p == NULL)
        return false;
    LNode *s = (LNode *) malloc(sizeof(LNode));
    if(s == NULL)
        return false;
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}
2.2.3 前插操作

在p结点之前插入元素e，可通过将p结点的后插操作，并把p结点的值赋给后继结点s，将e的值赋给p结点，即可实现前插操作

bool InsertPriorNode(LNode *p,ElemType e){
    if(p == NULL)
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if(s == NULL)
        return false;
    s->next = p->next;
    p->next = s;
    s->data = p->data;
    p->data = e;
    return true;
}
2.2.4 按位序删除（带头结点）
bool ListDelete(LinkList &L,int i,ElemType &e){
    if(i < 1)
        return false;
    LNode *p;    //指针p指向当前扫描到的结点
    int j = 0;   //当前p指向的是第几个结点
    p = L;       //L指向头结点，头结点是第0个结点（不存数据）
    while(p != NULL && j < i-1){  //循环找到第i-1个结点
        p = p->next;
        j++;
    }
    if(p == NULL)
        return false;
    if(p->next == NULL)
        return false;
    LNode *q = p->next;
    e = q->data;
  	p->next = q->next;
  	free(q);
    return true;
}
2.2.5 删除指定结点

但是这段代码在处理链表最后一个结点时，由于最后一个结点指向的是NULL，因此，没有data域，所以还是从头找到尾稳妥

bool DeleteNode(LNode *p){
	if(p == NULL)
		return false;
	LNode *q = p->next;
	p->data = p->next->data;
	p->next = q->next;
	free(q);
	return false;
}
2.2.6 单链表查找
按位查找
LNode * GetElem(LinkLisk L,int i){
	if(i<0)
		return NULL;
	LNode *p;
	int j = 0;
	p = L;
	while(p!=NULL && j = i){
		p = p->next;
		j++;
	}
	return p;
}
按值查找
LNode * LocateElem(LinkLisk L,int e){
	LNode *p = L->next;
	while(p != NULL && p->data != e){
		p = p->next;
	}
	return p;
}

求表的长度

int Length(LinkList L){
	int len = 0;
	LNode *p = L;
	while(p->next != NULL){
		p = p->next;
		len++;
	}
	return len;
}

2.3 建立单链表

2.3.1 尾插法建立单链表：

注意，此处函数类型为LinkList，且刚开始链表无内容，r指向的就是L的头结点，然后每次申请一个新的结点s，将其插在r的后面，最后修改指针，让r等于s即实现了尾插操作，最后让r指向NULL,就是要保证r永远指向最后一个结点

LinkList List_TailInsert(LinkList &L){ //正向建立单链表
    int x;
    L = (LinkList) malloc(sizeof(LNode));
    LNode *s,*r = L;
    scanf("%d",&x);
    while(x != 9999){
        s = (LNode*) malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;
        scanf("%d",&x);
    }
    r->next = NULL;
    return L;
}
2.3.2 头插法建立单链表：
重要应用：链表的逆置‼️ 
LinkList List_HeadInsert(LinkList &L){ //逆向建立单链表
    LNode *s;
    int x;
    L = (LinkList) malloc(sizeof(LNode)); //创建头结点
    L->next = NULL;                       //初始为空链表，为了防止头结点指向其他数据域
    scanf("%d",&x);
    while(x != 9999){
        s = (LNode*) malloc(sizeof(LNode)); //创建新结点
        s->data = x;
        s->next = L->next;
        L->next = s;
        scanf("%d",&x);
    }
    return L;
}

2.4 双链表

2.4.1 结点类型描述：
typedef struct DNode  //定义双链表结点类型
{
   ElemType data;  //数据域
   struct DNode *prior,*next;   //前驱和后继指针
}DNode , *DLinkList;
2.4.2 双链表的初始化
typedef struct DNode  //定义双链表结点类型
{
   ElemType data;  //数据域
   struct DNode *prior,*next;   //前驱和后继指针
}DNode , *DLinkList;

bool InitDLinkList(DLinkList &L){
    L = (DNode *) malloc(sizeof(DNode));
    if(L == NULL)
        return false;
    L->prior = NULL;
    L->next  = NULL;
    return true; 
}

void testDLinkList(){
    DLinkList L;
    InitDLinkList(L);
}

//判断双链表是否为空
bool Empty(DLinkList L){
    if(L->next == NULL)
        return true;
    else
        return false;
}
2.4.3 双链表的插入

在这里插入图片描述

bool InsertNextDNode(DNode *p,DNode *s){
    if(p == NULL || s ==NULL)
        return false;
    s->next = p->next;  //将结点*s插入到结点*p之后
    if(p->next != NULL)  //如果p有后继结点
        p->next->prior = s;  
    s->prior = p;
    p->next = s;
}
2.4.4 双链表的删除
bool DeleteNextDNode(DNode *p){ //删除p的后继结点
    if(p == NULL)
        return false;
    DNode *q = p->next;
    if(q == NULL)
        return false;
    p->next = q->next;
    if(q->next != NULL) //为了防止q结点后为空，导致指向前向指针出错
        q->next->prior = p;
    free(q);
    return true; 
}

void DestroyList(DLinkList &L){
  	//循环释放各个数据结点
    while(L->next != NULL)
        DeleteNextDNode(L);
    free(L);
    L = NULL;
}
2.4.5 双链表的遍历
2.4.5.1 后向遍历
while(p != NULL){
	p = p->next;
}
2.4.5.2 前向遍历
while(p != NULL){
	p = p->prior
}
2.4.5.3 前向遍历（跳过头结点）
while(p->prior != NULL){
	p = p->prior;
}

2.5 循环链表

2.5.1 循环单链表

在这里插入图片描述

初始化循环单链表：

bool InitList(LinkList &L){
    L = (LNode *) malloc(sizeof(LNode));
    if(L == NULL)
        return false;
    L->next = L;
    return true;
}

判断循环链表是否为空：

bool Empty(LinkList L){
	if(L->next ==L)
		return true;
	else
		return false
}
2.5.2 循环双链表

在这里插入图片描述

表头结点的prior指向表尾结点

表尾结点的next指向头结点

bool InitDLinkList1(DLinkList &L){
    L = (DNode *) malloc(sizeof(DNode));
    if(L == NULL)
        return false;
    L->prior = L;
    L->next  = L;
    return true;
}

void testDLinkList1(){
    DLinkList L;
    InitDLinkList1(L);
}

插入：

bool InsertNextDNode(DNode *p,DNode *s){
		s->next = p->next;
		p->next->prior = s;
		s->prior = p;
		p->next = s;
}

删除：

p->next = q->next;
q->next->prior = p;
free(q);

2.6 静态链表

分配一整片连续的内存空间，各个结点集中安置

0号结点充当”头结点“，游标充当”指针“，指向下一个结点的数组下标，游标为-1表示已经达到表尾

Alt

2.6.1 定义静态链表：
#define MaxSize 10  //静态链表的最大长度
struct Node{        //静态链表结构类型的定义
    ElemType data;  //存储数据元素
    int next;       //下一个元素的数组下标
};

void testSLinkList(){
    struct Node a[MaxSize]; //数组a作为静态链表
}

#define MaxSize 10  //静态链表的最大长度
typedef struct{        //静态链表结构类型的定义
    ElemType data;  //存储数据元素
    int next;       //下一个元素的数组下标
}SLinkList[MaxSize];

等价于

#define MaxSize 10  //静态链表的最大长度
struct Node{        //静态链表结构类型的定义
    ElemType data;  //存储数据元素
    int next;       //下一个元素的数组下标
};
typedef struct Node SLinkList[MaxSize];
void testSLinkList(){
  SLinkList a;
}
可用SLinkList定义“一个长度为MaxSize的Node型数组”
2.6.2 基本操作实现

  • 初始化静态链表：把a[0]的next设为-1，把其他结点的next设为-2来表示结点空闲

  • 查找：从头结点出发挨个往后遍历结点

  • 插入位序为i的结点：

    • 找到一个空的结点，存入数据元素
    • 从头结点出发找到位序为i-1的结点
    • 修改新结点的next
    • 修改i-1号结点的next

  • 删除某个结点：

    • 从头结点出发找到前驱结点
    • 修改前驱结点的游标
    • 被删除结点next设为-2
Marsbupt
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python统计字典中元素个数_Python计数器 | collections.Counter
weixin_39605905的博客
11-24 6494
问题：给定序列，统计所有元素出现的次数法一 ： seq.count()seq = 'abcdbabaecccdbb' #待统计序列#先变成集合得到seq中的所有元素，避免重复遍历set_seq = set(seq)rst = []for item in set_seq:rst.append((item,seq.count(item))) #添加元素及出现个数#输出结果,[('a', 3), (...
C++版数据结构第二章线性表总结
liulu2013jike01的专栏
10-06 889
一、线性表的逻辑结构 （1） 线性表的定义 1线性表：简称表，是n（n≥0）个具有相同类型的数据元素的有限序列。 2线性表的长度：线性表中数据元素的个数。 3空表：长度等于零的线性表，记为：L=(  )。 4非空表记为：L＝（a1,a2 , …,ai-1, ai ,…, an)。其中，ai（1≤i≤n）称为数据元素；下角标i表示该元素在线性表中的位置或序号。 （2）线性表的特性：
数据结构 第二章 线性表 期末复习总结
qq_51603003的博客
10-07 695
数据结构 严蔚敏 第二章线性表期末复习总结
数据结构--第二章 线性表
02-28
数据结构--第二章 线性表 我们老师的课件！
《数据结构》第二章线性表学习总结
HuangWeiJie2013GDOU
10-19 757
开学第5周，学完了我们大《数据结构》的第二章，
数据结构作业：第2章-线性表作业答案.docx
最新发布
12-16
数据结构作业：第2章-线性表作业答案 本文将详细解释数据结构中的线性表概念，並通過多个选择题和问题，帮助读者深入理解线性表的存储方式、操作和特点。 一、线性表的定义 线性表是一种具有n个有限序列（n>0）的...
数据结构作业：第2章-线性表作业题目.docx
12-16
"数据结构作业：第2章-线性表作业题目.docx" 在这份作业中，我们可以总结出以下几个重要的知识点： 1. 线性表的存储方式：线性表可以采用顺序存储和链式存储两种方式。顺序存储方式是指将所有元素存储在一片连续的...
数据结构课件第二章-线性表
10-04
数据结构课件第二章-线性表 本套课件公有10章 内容丰富 相信大家一定能学到有用的知识
王道第二章 -线性表的操作
07-16
线性表是数据结构中的基础概念，它是一个包含相同数据类型的有限序列，具有明确的前后顺序。线性表的特点包括：表长n大于等于0，空表时n为0；每个元素除了第一个之外都有唯一的直接前驱，除了最后一个之外都有唯一的...
数据结构第二章-线性表ppt教程
12-15
**线性表是一种基本且重要的数据结构，它在计算机科学中扮演着至关重要的角色。本教程将深入探讨线性表的理论与实现方法，主要分为两大部分：顺序映象和链式映象。** 首先，我们需要理解**线性表的定义**。线性表是...
数据结构习题——第二章 线性表
热门推荐
Colin丶
09-08 2万+
第二章 线性表 一、选择题 1．下述哪一条是顺序存储结构的优点？（ ） A．存储密度大 B．插入运算方便 C．删除运算方便 D．可方便地用于各种逻辑结构的存储表示 2．下面关于线性表的叙述中，错误的是哪一个？（ ） A．线性表采用顺序存储，必须占用一片连续的存储单元。 B．线性表采用顺序存储，便于进行插入和删除操作。 C．线性表采用链接存储，不必占用一片连续的存储单元。 D．线性表
C++ 单链表（无头结点）
qq_43650934的博客
11-17 4998
文章目录总结归纳代码实现 总结归纳 头结点可以没有，头指针必须有。访问整个链表，是用过遍历头指针来进行的。 这里没有特别的设置一个头指针，因为当指针指向整个链表 L 时，该指针的实现效果就是头指针。 不带头结点的单链表，即单链表的第一个结点就存储数据，头指针也指向第一个结点；带头结点的单链表，第一个结点是头结点，不存储数据，从头结点的 next 开始存储，头指针可以从头结点的 next 开始遍历。 对于结点的前插操作，找到对应位置的结点，设新结点为该节点的后继结点，将该结点的 data 后移至新结点的 d
读书笔记之《数据结构》---第二章 线性表
qq_25744595的博客
09-21 347
本章目录 线性表的类型定义 线性表的顺序表示和实现 线性表的链式表示和实现 一元多项式的表示及相加 线性表的类型定义 现行表示n个数据元素的有限序列。 抽象类型的线性表定义如下图： 书中给出两种算法实现两个线性表的合并： 线性表的顺序表示和实现 线性表的顺序表示指的是用一组地址连续的存储单元依次存储现行表的数据元素。 表中第i个元素的存储位置如下，其中l是每一个元素占的存储单元： 顺...
数据结构第二章：线性表
欢迎来到关关雎鸠儿的博客
08-12 2076
线性结构的基本特征: 线性结构是一个数据元素的有序（次序）集 1．集合中必存在唯一的一个“第一元素” 2．集合中必存在唯一的一个 “最后元素” 3．除最后元素在外，均有 唯一的后继 4．除第一元素之外，均有 唯一的前驱 一、线性表的基本概念 线性表L是n(n≥0)个具有相同属性的数据元素a1，a2，a3，…，an组成的有限序列，其中序列中元素的个数n称为线性表的长度。 当n=0时称为空表，即...
《数据结构》-第二章 线性表（知识点总结）
大家一起进步叭
06-25 4257
写在前面的话： 适应范围：《数据结构》复习总结系列适用于考研、期末考试、考前复习，小白新手 本系列参考书目： 《数据结构：c语言版》（严蔚敏） 关于写这个系列的原因：本人今年考研上岸，加上在校期间学习《数据结构》这门课时候，对数据结构有了好感，对这门课考试的考点把握还不错，所以不想荒废自己的知识，就计划用这种方式总结起来。如果有理解不到位的地方，欢迎在评论指出。我会尽量把知识点讲清楚后，按照考点进行总结。这个系列计划按照知识点总结后+考点总结，同时配有少部分习题（之...
《数据结构》第二章 线性表 知识总结导图
-木子的专栏
09-20 593
因为图比较大，分为
数据结构--第二章--线性表（顺序表、链表）--知识点回顾
iBin
01-07 3204
第二章 线性表 一、基本知识点 (1)线性表的顺序存储结构和链式存储结构的优缺点。 (2)顺序表的插人和删除操作过程及其实现。 (3)单链表的查找、插人和删除操作过程及其实现。 (4)双链表的查找、插人和删除操作过程及其实现。 (5)循环链表的查找、插人和删除操作过程及其实现。 (6)有序表的二路归并算法的思路及其实现算法，以及该算法的时间复杂度分析。 (7)利用线性表求解复杂的应用问题。 二、要点归纳、基本实现 1、线性表的特征： （1）有且仅有一个开始结点(表头结点)a1，它没有直接前驱，只有一个直
数据结构 第二章线性表总结
dianmaju9595的博客
03-14 124
1、本章内容小结 本章学习了线性表，下面通过两段代码展示顺序表和链表的基本操作。 //C++实现顺序表的基本操作 #include<iostream> #include<algorithm> using namespace std; #define MAXSIZE 1000 #define OVERFLOW -2 #define ERROR ...
数据结构第二章线性表总结
m0_50236851的博客
04-20 937
/*2.1线性表的定义和基本操作 InitList(&L);初始化表。 DestroyList(&L);销毁操作 LisInsert(&L,i,e);插入操作 LocateElem(L,e);按值查找 GetElem(L,i);按位查找 */ //2.2顺序表 // //2.21 //1 #define MaxSize 10 typedef struct { ElemType data[MaxSize]; int length; }SqList;//静态分配方式 void
数据结构第二章-线性表详解
"本章小结-数据结构第二章，主要涵盖了线性表的基本概念、顺序存储和链式存储的特点，以及单链表、双向链表和循环链表的介绍。" 在数据结构中，线性表是一个重要的基础概念，它是由n个数据元素构成的有限序列，每个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值