【顺序表】

最新推荐文章于 2024-06-03 22:50:30 发布
最新推荐文章于 2024-06-03 22:50:30 发布
阅读量116 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/student_wdqing/article/details/134926646
版权

目录

一、顺序表简介

   顺序表是在计算机内存中以数组形式保存的线性表。通俗来说，对于顺序表的增删查改等操作就是对于数组进行增删查改。
   一般对于数组来说有静态数组也有动态数组，即相对应的也有静态顺序表和动态顺序表。（本篇文章以动态顺序表来举例）

1）静态顺序表

   静态顺序表即在顺序表定义的时候就指定了顺序表的固定空间大小，不可扩增空间。

#include <stdio.h>
#include <stdlib.h>
#define SIZE 1000  //定义顺序表大小为SIZE大小

typedef int SLDataType;//将顺序表数据类型int定义为SLDataType
typedef struct SepList
{
	  SLDataType _data[SIZE]; //为顺序表开辟开辟SIZE大小的空间
	  int _size;           //_size表示顺序表中存储的数据个数 	                                                                                                                                     
}SL;  //定义顺序表并起别名为SL

2）动态顺序表

  动态顺序表，顾名思义顺序表的大小可重定义，根据应用的环境不同随时说明其维数大小。

#include <stdio.h>
#include <stdlib.h>

typedef int SLDataType;  //将顺序表数据类型int定义为SLDataType
typedef struct SepList 
{
  SLDataType* _data;		//动态顺序表指针，大小可变
  int _size;				//定义_size表示顺序表数据个数
  int _capacity;		    //定义_capacity为顺序表容量大小
}SL;	//定义顺序表并起别名为SL

二、顺序表初始化

void SLInit(SL* ps)//顺序表初始化
{
  if(NULL == ps)
  {
    perror("SepList Error Defined!");
    exit(1);
  }
  ps->_data = NULL;  //初始化数组空间为空
  ps->_size = 0;     //初始化有效数据个数为0
  ps->_capacity = 0; //初始化数据空间大小0
}

在这里插入图片描述
  顺序表初始化是为了构造一个空的顺序表，初始化数据，以防定义时的计算机赋予的随机值干扰后续操作，并检测顺序表是否成功定义。

三、顺序表插入数据

1）顺序表尾插

void SLPushBack(SL* ps, SLDataType x)//顺序表尾插
{
    assert(ps);

    SLCheckCapacity(ps);//检查顺序表空间是否足够，不够就开辟新的空间
    ps->_data[ps->_size++] = x;//尾部写入数据
}

  如下图所示，顺序表尾插就是在已开辟好的数组空间末尾写入要插入的数据。在函数SLPushBack接口中，assert断言检验顺序表是否成功创建后，会经过SLCheckCapacity函数接口检验顺序表容量是否足够，若不足够就开辟新的空间用以存储数据，后续会介绍到如何开辟空间，最后再在顺序表中写入数据。
  其中，顺序表SL中ps->_size代表顺序表数组中已存储的数据个数，根据数组下标的特性，它的数值指向数组最后数据的下一个坐标（如此做法是为了方便写入数据），如，当ps->_size为0时，它指向数组第0位，同时也代表了数组中数据个数为0；如下图，在数字4还没有写入时，ps->_size的值为3，代表了数据个数为3，同时又指向数组末尾数据下一个空间，此时要想插入数据就可利用ps->_data[ps->_size]直接访问这个空间，执行完成后ps->_size++结果为4，结果解释同理。
在这里插入图片描述

2）顺序表头插

void SLPushFront(SL* ps, SLDataType x)//顺序表头插
{
    assert(ps);//检验顺序表是否定义成功
    SLCheckCapacity(ps);//检查空间是否足够，不够就重新开辟
	
	//定义end从后往前访问数组，在end + 1位置写入数据
    int end = ps->_size - 1;
    while (end >= 0)
    {
        ps->_data[end + 1] = x;
        end--;
    }
    ps->_data[0] = x;//数组头部写入数据
    ps->_size++;//顺序表内部存储的数据个数加1
}

  如下图所示，顺序表头插其原理就是将整个数组的数据从后往前挪动一位，挪动完成后，再利用ps->_data[0]直接在头部写入数据。
在这里插入图片描述

3）pos位置插入数据

void SLInsert(SL* ps, int pos, SLDataType x)//pos位置插入数据
{
    assert(ps);//检验顺序表是否定义成功
    assert(pos >= 0 && pos <= ps->_size);//数据插入位置需在包括数组开头和末尾这个区间之间

    SLCheckCapacity(ps);//检查空间是否足够，不够就重新开辟
    int end = ps->_size - 1;//定义end从后往前访问数组，在end + 1位置写入数据
    while (end >= pos)//数据挪动，挪动完至pos位置后停止挪动
    {
        ps->_data[end + 1] = ps->_data[end];
        end--;
    }
    ps->_data[pos] = x;//pos位置写入数据
    ps->_size++;//顺序表内部存储的数据个数加1
}

  如下图所示，顺序表任意位置插入数据其原理同顺序表头插类似，只是将头部固定位置换成了任意位置。
在这里插入图片描述
  根据此接口原理，可以将顺序表头插以及尾插更换如下：

//顺序表头插
void SLPushFront(SL* ps, SLDataType x)//顺序表头插
{
	SLInsert(ps, 0, x);//复用SLInsert接口在头部插入数据
}

//顺序表尾插
void SLPushBack(SL* ps, SLDataType x)//顺序表尾插
{
    SLInsert(ps, ps->_size, x);//复用SLInsert接口在尾部插入数据
}

4）动态开辟空间

void SLCheckCapacity(SL* ps)//动态开辟  
{
	assert(ps);//检验顺序表是否定义成功
	
    if (ps->_size == ps->_capacity)//如果已存储数据个数等于已开辟的空间容量，执行后续代码，开辟新的空间
    {
    	//设置顺序表容量(newCapacity)的大小
    	//若容量为0，则设置容量空间大小为4(本篇数据类型为int,则容量4代表 4 * 4 byte大小空间)
    	//若容量不为0，则设置容量大小为原本容量大小的两倍
        int newCapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
        //开辟newCapacity大小空间(开辟空间使用realloc接口)
        SLDataType* newData = (SLDataType*)realloc(ps->_data, newCapacity * sizeof(SLDataType));
        if (NULL == newData)
        {
            perror("Realloc Fail!");
            exit(-1);
        }
        //将新开辟的空间地址交给顺序表
        ps->_data = newData;
        //将新的容量大小告诉顺序表
        ps->_capacity = newCapacity;
    }
}

  具体如何开辟空间由上述代码注释部分可给出，下面举两个例子观看经过SLCheckCapacity接口后开辟空间以及存储的数据在存储空间中位置的变化：

1> 例一：SLCheckCapacity内部执行

在这里插入图片描述
  如上图所示，此状态为顺序第一次访问SLCheckCapacity接口，其中_data存储的地址为空。
在这里插入图片描述
  由后续代码执行完成后，由上图可见，_data指针变量存储的地址为0x0000027F89420460（图中有些小瑕疵，红框框错了范围，已由蓝线标出），一个int 类型大小为4byte,所以开辟出来能存储4个int大小的数据的空间为4 * 4 （16）byte的连续空间，由图可见，这些空间已经被赋随机初始值0xcdcdcdcd（VS在debug环境下，一般将内存填充为0xcccccccc或0xcdcdcdcd）。

2> 例二：SLCheckCapacity外部执行

#include<stdio.h>
#include"SepList.h"

//测试用例
int main()
{
	SL s;

	SLInit(&s);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPrint(&s);

	SLPushFront(&s, 100);
	SLPushFront(&s, 99);
	SLPushFront(&s, 98);
	SLPushFront(&s, 97);
	SLPrint(&s);
	
	SLInsert(&s, 0, 10);
	SLPrint(&s);

	SLInsert(&s, s._size, 20);
	SLPrint(&s);

	return 0;
}

图2-1
  由上图，此时可见顺序表执行初始化后空间未开辟状态。
图2-2
  由上图，执行完成第一步SLPushBack，可见在空间中的地址0x000001AC592D0280处写入了想要尾插的数据0x00000001（内存中以16进制存储，具体空间开辟过程参考SLCheckCapacity接口代码与上述例一），这种数据低位存储在低地址处的方法为小端法。
在这里插入图片描述
  由上图，当执行完所有SLPushBack时候，可见所有尾插数据都依次存储在开辟出来的连续空间中。
在这里插入图片描述
  由上图，可见执行完所有SLPushFront后空间种的存储，图中插入数据时空间不够又重新开辟了空间，可见_data为0x000001AC592D0A70，及此地址后4 * 8 byte连续空间。
图2-4
  由上图，复用SLInsert头插数据，空间不够重新开辟二倍大小空间，此时_data为0x000001AC592CA000。
图2-5
  由上图，复用SLInsert尾插数据（容量足够，无需开辟空间），可见空间中数据的存储位置以及结果打印。
  注意：上述例子在开辟空间时，_data中存储的地址经过三次扩容就发生了三次变化，为什么不能不变呢？这个涉及到realloc的扩容机制（原地扩容与异地扩容，本篇文章暂不提及，感兴趣的可以去查查资料）。

四、顺序表删除数据

1）顺序表尾删

void SLPopBack(SL* ps)//顺序表尾删
{
    assert(ps);//检验顺序表是否定义成功

    if (ps->_size == 0) return;//如果顺序表中数据个数为空，则直接返回
    ps->_size--;			   //否则，ps->_size - 1
}

  顺序表尾删数据，说白了就是让顺序表存储的数据个数(_size)减1，由上述代码和下图可见，即直接让ps->_size - 1即可（因为顺序表是通过_size知道顺序表有多少个数据以及由此来限制顺序表的访问范围，其值减1后就如同告诉我们：原本最后的空间不能再访问，那里没有存储数据）。
在这里插入图片描述

2）顺序表头删

void SLPopFront(SL* ps)//顺序表头删
{
    assert(ps);//检验顺序表是否定义成功

	//数据挪动
    int begin = 1;
    while (begin < ps->_size)
    {
        ps->_data[begin - 1] = ps->_data[begin];
        begin--;
    }
    ps->_size--;
}

  顺序表头删，其基本操作就是将第0位之后的数据统统往前挪动一位，由下图可见，数据挪动完，将ps->_size的值减1即可，原本最后一位的5无需再管它（同顺序表尾删），ps->_size限制了顺序表的访问范围。
在这里插入图片描述

3）删除pos位置数据

void SLErase(SL* ps, int pos)//删除pos位置数据
{
    assert(ps);//检验顺序表是否定义成功
    assert(pos >= 0 && pos < ps->_size);//能够删除的数据位置在数组下标范围为[0,ps->_size - 1]中

	//数据挪动
    int begin = pos + 1;
    while (begin < ps->_size)
    {
        ps->_data[begin - 1] = ps->_data[begin];
        begin++;
    }
    ps->_size--;
}

  由下图可见，删除pos位置数据操作类似顺序表头删，不做过多解释。
在这里插入图片描述

  根据此接口原理，可以将顺序表头删以及尾删更换如下：

//顺序表头删
void SLPopFront(SL* ps)//顺序表头删
{
	SLErase(ps, 0);//复用SLErase接口
}

//顺序表尾删
void SLPopBack(SL* ps)//顺序表尾删
{
	SLErase(ps, ps->_size - 1);//复用SLErase接口
}

五、查找数据

//从begin位置开始寻找x
//寻找到了返回x位置
//失败返回-1
int SLFind(SL* ps, SLDataType x, int begin)
{
    assert(ps);
    assert(begin >= 0 && begin < ps->_size);

    for (int i = begin; i < ps->_size; i++)
    {
        if (x == ps->_data[i])
        {
            return i;
        }
    }
    return -1;
}

六、打印顺序表

void SLPrint(SL* ps)//打印顺序表
{
    assert(ps);

    for (int i = 0; i < ps->_size; i++)
    {
        printf("%d ", ps->_data[i]);
    }
    printf("\n");
}

七、销毁顺序表

void SLDestroy(SL* ps)//销毁顺序表
{
    assert(ps);

    if (ps->_data)
    {
        free(ps->_data);//释放申请的空间
        ps->_data = NULL;//将指针变量置空
        ps->_capacity = ps->_size = 0;//将容量以及数据个数置0
    }
}
//销毁顺序表是为了防止内存泄漏，不能对于不再使用的内存置之不理

八、总览

1）SepList.h

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int SLDataType;
typedef struct SepList
{
	SLDataType* _data;
	int _size;
	int _capacity;
}SL;

void SLInit(SL* ps);//顺序表初始化，ps(point to SL) 

void SLCheckCapacity(SL* ps);//动态开辟

void SLPrint(SL* ps);//打印顺序表

void SLDestroy(SL* ps);//销毁顺序表

void SLPushBack(SL* ps, SLDataType x);//顺序表尾插

void SLPopBack(SL* ps);//顺序表尾删

void SLPushFront(SL* ps, SLDataType x);//顺序表头插

void SLPopFront(SL* ps);//顺序表头删 

void SLInsert(SL* ps, int pos, SLDataType x);//pos位置插入数据

void SLErase(SL* ps, int pos);//删除pos位置数据

int SLFind(SL* ps, SLDataType x, int begin);//查找数据

2）SepList.c

#include<assert.h>
#include "SepList.h"

void SLInit(SL* ps)//顺序表初始化
{
    if (NULL == ps)
    {
        perror("SepList Error Defined!");
        exit(1);
    }
    ps->_data = NULL;  //初始化数组指针为空
    ps->_size = 0;     //初始化数据个数为0
    ps->_capacity = 0; //初始化数据空间大小0
}


void SLCheckCapacity(SL* ps)//动态开辟  
{
    if (NULL == ps)
    {
        perror("SepList Error Defined!");
        exit(1);
    }
    if (ps->_size == ps->_capacity)
    {
        int newCapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
        SLDataType* newData = (SLDataType*)realloc(ps->_data, newCapacity * sizeof(SLDataType));
        if (NULL == newData)
        {
            perror("Realloc Fail!");
            exit(-1);
        }
        ps->_data = newData;
        ps->_capacity = newCapacity;
    }
}


void SLPrint(SL* ps)//打印顺序表
{
    assert(ps);

    for (int i = 0; i < ps->_size; i++)
    {
        printf("%d ", ps->_data[i]);
    }
    printf("\n");
}


void SLDestroy(SL* ps)//销毁顺序表
{
    assert(ps);

    if (ps->_data)
    {
        free(ps->_data);
        ps->_data = NULL;
        ps->_capacity = ps->_size = 0;
    }
}


void SLPushBack(SL* ps, SLDataType x)//顺序表尾插
{
    assert(ps);

    SLCheckCapacity(ps);
    ps->_data[ps->_size++] = x;
}


void SLPopBack(SL* ps)//顺序表尾删
{
    assert(ps);

    if (ps->_size == 0) return;
    ps->_size--;
}

void SLPushFront(SL* ps, SLDataType x)//顺序表头插
{
    assert(ps);
    SLCheckCapacity(ps);

    int end = ps->_size - 1;
    while (end >= 0)
    {
        ps->_data[end + 1] = x;
        end--;
    }
    ps->_data[end] = x;
    ps->_size++;
}


void SLPopFront(SL* ps)//顺序表头删
{
    assert(ps);

    int begin = 1;
    while (begin < ps->_size)
    {
        ps->_data[begin - 1] = ps->_data[begin];
        begin--;
    }
    ps->_size--;
}


void SLInsert(SL* ps, int pos, SLDataType x)//pos位置插入数据
{
    assert(ps);
    assert(pos >= 0 && pos <= ps->_size);

    SLCheckCapacity(ps);
    int end = ps->_size - 1;
    while (end >= pos)
    {
        ps->_data[end + 1] = ps->_data[end];
        end--;
    }
    ps->_data[pos] = x;
    ps->_size++;
}


void SLErase(SL* ps, int pos)//删除pos位置数据
{
    assert(ps);
    assert(pos >= 0 && pos < ps->_size);

    int begin = pos + 1;
    while (begin < ps->_size)
    {
        ps->_data[begin - 1] = ps->_data[begin];
        begin++;
    }
    ps->_size--;
}


//从begin位置开始寻找x
//寻找到了返回x位置
//失败返回-1
int SLFind(SL* ps, SLDataType x, int begin)
{
    assert(ps);
    assert(begin >= 0 && begin < ps->_size);

    for (int i = begin; i < ps->_size; i++)
    {
        if (x == ps->_data[i])
        {
            return i;
        }
    }
    return -1;
}

九、C++顺序表草稿

  此部分仅为C++顺序表草稿，后续会再更改。
  C++顺序表

student_wdqing
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
顺序表和链表
passion
08-03 2911
顺序表和链表的简单介绍和实现
顺序表实现
11-05
Java顺序表的学习实现代码，支持多种数据类型的临时存储
顺序表
Outtch_的博客
11-07 3538
顺序表是什么呢？ 顾名思义，顺序表是物理地址连续的存储单元依次存储数据的线性结构，一般情况下采用数组存储，在数组上完成数据的增删查改。 顺序表和数组有什么区别呢? 顺序表比数组更约束，顺序表物理地址上必须连续存储，数组是顺序表在实际编程中的具体实现方式。 顺序表分为静态顺序表和静态顺序表（主要区别在于他们的容量是否可变） 静态顺序表 静态顺序表的概念： 顺序表的容量在静态时期（编译期间）确定，大...
顺序表的基本操作（超详细）
m0_56992713的博客
10-16 11万+
1.顺序表的定义 使用结构体来构造一个顺序表。 typedef struct { int length;//当前顺序表长度 int Maxsize;//顺序表最大长度 int* data;//定义顺序表中元素类型的数组指针 }SqList; 2.顺序表的初始化 顺序表的初始化是使用动态分配数组空间方式构造一个空的线性表。 #include<stdio.h> #include<stdlib.h> #define InitSize 10 void InitList(SqList
顺序表详解
weixin_65132948的博客
04-24 2万+
目录 一、线性表的概念 二、顺序表 1、顺序表的概念 1）. 静态顺序表：使用定长数组存储元素。 2）. 动态顺序表：使用动态开辟的数组存储。 三、接口实现 1、创建 2、初始化 3、扩容 4、尾插 5、打印 6、销毁 7、尾删 越界： 8、头插 9、头删 10、任意位置插入 11、删除任意位置 12、查找 13、修改 一、线性表的概念 【百度百科】 线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是...
掌握顺序表：从概念到C语言实现
howard2005的专栏
01-16 2万+
C语言实现顺序表的创建与增删改查操作
数据结构-顺序表基本操作的实现（含全部代码）
热门推荐
关注网络安全、云原生安全
09-13 21万+
今天起开始编写数据结构中的各种数据结构及其算法的实现。 主要依据严蔚敏版数据结构教材以及王道数据结构考研辅导书。 今天是线性表中的顺序表的实现，主要实现函数如下，读者有需要可以评论，我可以适当加几个。 CreatList(SqList &L,int n) 参数：顺序表L，顺序表长度n 功能：创建长度为的顺序表 时间复杂度：O(n) InitList(SqList &...
什么是顺序表
kokopop007的博客
08-25 1万+
顺序表 在程序中，经常需要将一组（通常是同为某个类型的）数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，传进传出函数等。一组数据中包含的元素个数可能发生变化（可以增加或删除元素）。 对于这种需求，最简单的解决方案便是将这样一组元素看成一个序列，用元素在序列里的位置和顺序，表示实际应用中的某种有意义的信息，或者表示数据之间的某种关系。 这样的一组序列元素的组织形式，我们可以将其抽象为...
＜数据结构＞ 顺序表
bit_zyx的博客
03-13 9247
目录 一、顺序表介绍 二、准备工作 1、创建顺序表 2、初始化顺序表 3、检测是否需要扩容 4、销毁顺序表 5、打印顺序表 三、四大功能 1、增加数据 头插 尾插 指定下标插入 2、删除数据 头删 ...
C语言实现顺序表
辰多代码的博客
07-26 1881
1.2 SeqList.c 1.3 test.c 二、顺序表的实现 2.1 顺序表 创建一个顺序表结构体，成员包含顺序表地址、长度、大小，用于创建顺序表变量。 将顺序表变量的地址传参，通过指针接收对顺序表的顺序表数组初始化为空，长度为0，大小为0。 同样传地址，要先断言指针是否为空，不然会出异常。然后判断顺序表大小是否为0，为0则代表顺序表中没有有效元素，打印提示，并返回函数，如果大于0，则有元素，从下标0开始，打印size个顺序表元素，并用空格相隔。 当我们结束程序
《Java数据结构入门》顺序表详解
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
04-25 5474
带你手把手自己模拟实现Java数据结构中的顺序表，很详细的哟😁
1_顺序表_
10-02
基于顺序存储结构的图书信息表的创建和输出描述定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后统计图书表中的图书个数，同时逐行输出每本图书的信息。...
2_顺序表_
10-01
基于顺序存储结构的图书信息表的修改描述定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据完成图书信息表的创建，然后计算所有图书的平均价格，将所有低于平均价格的图书价格提高20%，所有...
小白算法积累——顺序表6#有序顺序表 +删除重复元素
01-07
题目：从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不同。 关键字：有序顺序表 删除重复元素 思路 关注：因为是有序表，所以值相同的元素一定在连续的位置上， 用类似于直接插入排序的思想 1.初始时...
顺序表+菜单
06-18
里面包括顺序表的创建，更改，添加，删除元素，遍历顺序表包括菜单功能，代码清晰，结构简单
【数据结构】链表与顺序表的比较
SWsunlight的博客
06-01 915
顺序表和链表比较
数据结构-哈希表
weixin_42035282的博客
06-01 443
哈希表是一种高效的数据结构，它可以提供快速的插入、删除和查找操作。哈希表的基本思想是将键通过一个哈希函数映射到一个连续的地址空间上，然后在这个地址空间上进行查找、插入和删除操作。下面将详细介绍哈希表的相关概念和实现方法。
day2数据结构
m0_62438849的博客
05-31 278
L 因为L会发生变化 & 引用在 C 语言中，参数传递不支持引用（&）的方式，应该使用指针来传递参数数组的赋值不能使用 = 直接赋值整个数组。需要逐个赋值数组的元素，或者使用循环来初始化数组//定义线性表的最大长度int length;}SqList;return -1;i < 5;i++){\n");return 0;
数据结构：链式队列
最新发布
weixin_67035108的博客
06-03 570
链式队列，指的是使用链表实现的队列，是一种常见的数据结构。队列遵循先进先出（FIFO）的原则，即最先进入队列的元素将是最先被移除的元素。链式队列通过链表的动态特性来实现队列的插入和删除操作，提供了比静态数组实现的队列更高的灵活性。： 链式队列需要维护两个指针：队首指针（指向队列的第一个元素）和队尾指针（指向队列的最后一个元素）。： 由于链式队列的元素是动态添加的，因此需要使用动态内存分配来创建新的节点。： 链式队列由一系列节点组成，每个节点通常包含两个部分：数据部分和指向下一个节点的指针
顺序表 displist
03-09
顺序表（displist）是一种线性表的存储结构，它通过一段连续的存储空间来存储元素，元素之间的逻辑关系由下标来表示。顺序表的特点是可以随机访问元素，时间复杂度为O(1)。 顺序表的实现方式有多种，其中一种常见的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值