数据结构线性表篇-顺序表的实现

已于 2024-04-16 20:28:41 修改
阅读量746 收藏 26
点赞数 22
分类专栏： 数据结构与算法 文章标签： 数据结构 链表
于 2024-04-16 20:26:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76874759/article/details/137822602
版权

1.数据结构的介绍

⚀基本概念

数据结构 == 数据 + 结构

  • 数据：
    • 数据就是所有描述客观事物的符号。
    • 比如：我们常见的文字，“你今天学习了吗？”；数字，“1，2，3，4，5，...”；每天刷的视频，拍的照片，听的音乐......这些都是数据。【大家应该都知道什么数据的，抽象的概念，小编也不能完全解释清楚】
    • 对于计算机而言：简单的数据可以是一个整形数字，一个字符，一个浮点型数字；稍微复杂点，可以是一串字符，一堆存放在结构体中的复杂数据等等。
  • 结构：
    • 结构是指数据元素之间的相互关系。
    • 简单的说：有了数据，就要交给计算机进行存储，而存储数据就有不同的方式，我们将存储数据的方式称为数据的结构。
    • 比如：数据是一个接着一个的存放，数据是像一棵树一样，从主干到分支等等。
  • 数据结构： 
    • 现在来谈数据结构就更容易理解了，数据结构就是一句话：数据存放的方式。
    • 数据结构是计算机存储、组织数据的方式。

⚁常见的数据结构

当我们了解了数据结构的基本概念之后，再为大家介绍一下常见的数据结构：

数据结构可以从两方面来分析：逻辑结构和物理结构

  • 逻辑结构：
    • 逻辑结构就是指我们实际看见的存放数据的结构。
  • 物理结构：
    • 物理结构就是指数据实际在内存上的存储方式。
  • 以下面要介绍的线性表为例子，线性表就是数据元素串联起来，形成一条线，如图，在表面看来这些数据一个接着一个存储的（逻辑结构），但是在底层的实现时，这些数据在内存上，可能是连续的，分散的（物理结构）。

2.线性表的介绍

⚀基本概念

小编的理解：

        线性表就是将n个具有相同特性、相同类型的数据一个一个地链接起来，使得数据存放的方式在逻辑结构上看起来是一条直线，一条连续的存放数据的直线。

星火的解释：

        线性表是数据结构的一种，它是由n个具有相同特性的数据元素组成的有限序列。

        线性表是一种最基本的数据结构，它可以看作是一组有序的元素集合，每个元素都有唯一的前驱和后继（除了第一个和最后一个元素）（小编注解：每个元素前面和后面都有元素，除了开头和结尾）。

        【补充】这种结构体现了数据元素之间的一对一关系。线性表可以进一步分为一般线性表和受限线性表，其中受限线性表可能对元素的排列或操作有一定的限制。

⚁线性表的分类

        线性表在逻辑结构上看起来是一条直线，数据都在直线线上，那么按照物理结构来分，就会存在真~直线和假~直线两种，就是数据之间存储是连续的和不连续的两种，连续的被称作顺序表，不连续的被称为链表：

  • 顺序表：
    • 顺序表中的元素按逻辑顺序依次存储在计算机内存中连续的物理地址空间中。
  • 链表：
    • 链表是用一组任意的物理地址来存储数据元素，数据元素（节点）之间的关系通过指针来进行链接。

3.顺序表的实现

        顺序表就物理上连续存放的数据结构，那么底层其实就是数组，只有数组才是连续存放的，我们所讲的顺序表大家就将其理解为数组就可以了，顺序表只不过在数组上对其进行封装成了结构体（添加了数组的实际元素个数和数组的容量）。

        而数组又分为两种静态开辟的数组和动态开辟的数组两种：

  • 静态开辟的数组：
    • 创建方式：使用类型加上数组的下标引用符表示一个数组的创建
    • 特点：空间连续，大小一开始规定好了，无法调整。
  • 动态开辟的数组：
    • 创建方式：使用动态开辟函数开辟一块空间，再结合不同类型的指针进行访问，就形成了数组。
    • 解释：指针的类型决定了指针一次性访问多少个字节的空间，决定了加一时跳过几个字节的空间，通过不同类型的指针去访问空间，由于不同类型指针的特性，一次性访问空间大小就不同，
    • 比如int*去访问空间，一次就能读取int（字节）个空间，那不就访问一个整形数据吗？再配合指针运算的特性，加一不就跳过一个int类型的元素吗？那我开辟n个int类型的空间，再用int*去访问，这不就是长度为n的整形数组了
    • 特点：空间连续，大小可变，可以调整。

那么了解完静态和动态后，大家觉得我们要基于哪种去实现顺序表？

        答案肯定是动态啦，静态的大小不可变，如果你以后工作了使用静态的存储数据，那么如果数据量比较大，就会面临空间不够用，小了就会面对数据存不下溢出导致数据丢失，哪种情况哪都担待不起，丢了重要数据那你只剩下手铐作伴了，而动态开辟的就能防止这种情况。

下面就基于动态开辟的数组，来为大家一步一步剖析顺序表的实现

⚀大致思路

顺序表的实现大致就是顺序表的定义、顺序表功能的实现和功能的测试等。

而代码的量比较大，我们采用模块化编程，将声明、定义和测试/使用分开放置，进行实现，可以提高代码的可维护性、可读性和重用性：

  • 创建三个文件：
    • 文件1：头文件SeqList.h，顺序表的定义和顺序表功能的定义。
    • 文件2：源文件SeqList.c，存放顺序表功能的实现。
    • 文件3：源文件SeqList_test.c，存放顺序表的测试和使用。
使用头文件和源文件分开代码的好处

⚁拆解分析 

        首先，先在头文件SeqList.h定义好我们的结构体，声明好所有要实现的功能，这样你才知道大致需要实现哪些功能，思路才会清晰。接着再去源文件SeqList.c实现函数，最后再在源文件SeqList_test.c测试实现的功能。

(1).头文件SeqList.h

大致思路
🌵#include包含头文件🌵
#pragma once//头文件只被重复包含一次
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

头文件包含了库文件之后，再顺序表的函数实现的源文件中就不需要再包含了，只需要包含SeqList.h即可

🌵顺序表的声明与定义🌵
struct SeqList
{
	SLDataType* arr;//指向顺序表空间的地址
	int size;//顺序表实际元素个数
	int capacity;//顺序表的总容量
};

前面我们说过顺序表就是动态开辟的数组之上，加上数组的元素实际大小和总容量这两个参数进行封装，那不用多说肯定是用到结构体，当然出了这个数和容量这两个参数，还可以添加其他的。

如果觉得创建顺序表的关键字太长了，可以重新命名一下：

//顺序表创建的关键字太长了，重新命名一下
typedef struct SeqList SL;

注意的是：这里指向顺序表的指针采用的类型是我们自己定义的类型，就是方便适用于不同类型的数据，所以在定义顺序表前，我们再加上一句对顺序表元素类型关键字的重命名语句：

//先来定义一下顺序表的元素类型名
typedef int SLDataType;
🌵顺序表功能的声明🌵 

下面的函数我统一采用了传地址调用，因为传值调用是对拷贝值修改，不对实际参数做修改，那么初始化、插入、删除、修改、销毁就会出错，而打印函数你们可以选择传值，这里不涉及到实参的修改。

//顺序表功能的定义

//顺序表的初始化和销毁
void SLInit(SL* ps);//对顺序表的实际值进行修改，不能传值，因为传值是对原顺序表的拷贝，修改的拷贝值
void SLDestroy(SL* ps);

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

//顺序表的内存大小的判断
void SLCheckCapacity(SL* ps);

//顺序表的插入数据
//1.头部插入数据
void SLPushHead(SL* ps,SLDataType x);
//2.尾部插入数据
void SLPushTail(SL* ps, SLDataType x);
//3.指定位置前插入数据
void SLPushFront(SL* ps,int pos,SLDataType x);
//4.指定位置后插入数据
void SLPushBack(SL* ps,int pos, SLDataType x);

//顺序表的删除数据
//1.头部删除数据
void SLPopHead(SL* ps);
//2.尾部删除数据
void SLPopTail(SL* ps);
//3.指定位置前删除数据
void SLPopFront(SL* ps,int pos);
//4.指定位置后删除数据
void SLPopBack(SL* ps,int pos);
//5.指定位置删除
void SLPop(SL* ps, int pos);

//顺序表的查找数据
void SLFind(SL* ps, SLDataType x);

//顺序表的修改数据
void SLModfiy(SL* ps,int pos,SLDataType);

(2).源文件SeqList.c

🌵顺序表的初始化🌵

初始化的方式分为两种：

  • 初始化不开辟空间，将指针置为NULL，则将个数和容量都置为0
  • 初始化时开辟空间，一般采用4/8个元素大小进行开辟，此时容量就要置为4/8，而个数为0

这里小编采用第一种。还需注意的时初始化的方式不同，导致容量的初始值不同，那么在实现判断容量大小函数时，一般都会扩容容量的2/3倍，采用第一种方式容量可能0，那么在扩容前一定要判断容量是否0的情况。

void SLInit(SL* ps)//对顺序表的实际值进行修改，不能传值，因为传值是对原顺序表的拷贝，修改的拷贝值
{
	assert(ps);//传指针就要断言一下，防止为空指针，后面都是如此
	//初始化可以选择设置有效初始大小和无效初始大小（NULL和0）
	//我们这里选择后者，不开辟初始空间
	ps->arr = NULL;//置为空，无初始空间
	ps->size = ps->capacity = 0;
}
 🌵顺序表的销毁🌵
void SLDestroy(SL* ps)
{
	assert(ps);
	if (ps->arr != 0)//空间有效才销毁，没有开辟空间就没必要销毁了
	{
		free(ps->arr);//销毁空间，防止内存泄漏
		ps->arr = NULL;//指针置为空，规避野指针
	}
	ps->size = ps->capacity = 0;//个数和容量置为初始状态的值
}
       🌵容量判断函数🌵

易错点：

  • 忽略capacity为0的情况，直接扩容为2/3倍
  • 忽略动态开辟函数可能存在失败的情况，直接就将新地址和新容量的值赋值给变量，如果扩容失败的情况那么原来的参数就丢失，所以必须再验证后，再将参数设置为新的数值
//顺序表的内存大小的判断
void SLCheckCapacity(SL* ps)
{
	//判断容量大小就是判断实际元素个数size和总容量的数目是否相等
	if (ps->size == ps->capacity)//如果相等就扩容2倍
	{
		//存在问题1：实际元素个数和容量大小可能等于0，那就是还没有开辟空间
		//使用三目操作符判断一下
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		//如果等于0，我们就将它设置为4，不等于就返回2倍的大小，同时使用新的容量变量接收
		//此时要扩容容量的数值就不为0了，可以开始扩容
		SLDataType* arr_tmp = (SLDataType*)realloc(ps->arr, newcapacity * sizeof(SLDataType));
		//realloc可能扩容失败，所以不直接使用ps->arr进行接收，会导致原空间起始地址丢失的情况
		if (arr_tmp == NULL)//判断是否失败
		{
			perror("realloc");//打印错误
			return;//扩容失败了，可以结束函数了
		}
		//扩容成功，新空间的地址赋值给存原空间的变量，新容量大小赋值给存旧容量大小的变量
		ps->arr = arr_tmp;
		ps->capacity = newcapacity;
	}
	//不相等就不要扩容
}
  🌵头部插入和尾部插入🌵
//顺序表的插入数据
//1.头部插入数据
void SLPushHead(SL* ps,SLDataType x)
{
	assert(ps);
	//插入数据前，判断空间是否足够
	SLCheckCapacity(ps);
	//保证足够后开始插入数据
	//分析：头部插入，所有数据向后移动一位，从前向后会导致还未被移动的数据被覆盖掉，影响后续移动
	//		所以采用从后向前移动
	//这里给推荐大家一个方法：如果你不知道循环进行几次，先定义一个变量count存放循环的次数，先分析count的值，再循环
	int count = ps->size;//这里要移动所有数据，那么进行size次
	for (int i = 0; i < count; i++)
	{
		ps->arr[ps->size - i] = ps->arr[ps->size - i - 1];
		//不清楚的同学还可以假设第一次循环和最后一次循环来验证一下
		//第一次：ps->arr[ps->size]=ps->arr[ps->size-1];就是最后一个元素的值赋值到后面一个元素的位置
		//最后一次：i=count-1=ps->size-1;ps->arr[1]=ps->arr[0];就是第一个元素的值赋值到第二个元素的位置
	}
	//移动完后就开始插入数据
	ps->arr[0] = x;//把第一个位置的值置为目标变量值x
	//插入一个数据后不要忘记实际元素个数+1
	ps->size++;
}

从前向后替换数据就会导致还未被移动的数据丢失
循环分析 
//2.尾部插入数据
void SLPushTail(SL* ps, SLDataType x)
{
	assert(ps);
	//插入数据前，判断空间是否足够
	SLCheckCapacity(ps);
	//保证足够后开始插入数据
	//分析：尾部插入不需要移动数据，直接在后面插入数据
	ps->arr[ps->size] = x;//下标为size的元素是第size+1个元素，下标和序号差-1，不知道的数组在内存中的存储就没学好
	//插入一个数据后不要忘记实际元素个数+1
	ps->size++;
}
🌵指定位置前插入🌵
//3.指定位置前插入数据
void SLPushFront(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	//插入数据前，判断空间是否足够
	assert(pos > 0 && pos <= ps->size);
	SLCheckCapacity(ps);
	//保证足够后开始插入数据
	//分析：头部插入，指定数据向后移动一位，从前向后会导致还未被移动的数据被覆盖掉，影响后续移动
	//		所以采用从后向前移动
	//这里给推荐大家一个方法：如果你不知道循环进行几次，先定义一个变量count存放循环的次数，先分析count的值，再循环
	//第1个元素前有0个元素，第3个元素前有2个元素，那么第pos个元素前就有pos-1个元素
	int count = ps->size - (pos - 1);//移动的是指定位置后的数据，那么包括第pos个元素也要移动，就是总的减去第pos前的元素个数
	for (int i = 0; i < count; i++)
	{
		ps->arr[ps->size - i] = ps->arr[ps->size - i - 1];
		//不清楚的同学还可以假设第一次循环和最后一次循环来验证一下
		//第一次：ps->arr[ps->size]=ps->arr[ps->size-1];就是最后一个元素的值赋值到后面一个元素的位置
		//最后一次：i=count-1=ps->size-pos;ps->arr[pos]=ps->arr[pos-1];就是第pos个元素的值赋值到第pos个元素后一个元素的位置
	}
	//此时第pos个元素(下标pos-1)的位置处没有数据，就插入给定数据x
	ps->arr[pos - 1] = x;
	//插入一个数据后不要忘记实际元素个数+1
	ps->size++;
}

  🌵头部删除和尾部删除🌵
//顺序表的删除数据
//1.头部删除数据
void SLPopHead(SL* ps)
{
	assert(ps);
	//分析：头部删除，所有数据向前移动一位，从后向前会导致还未被移动的数据被覆盖掉，影响后续移动
	//		所以采用从前向后移动
	//这里给推荐大家一个方法：如果你不知道循环进行几次，先定义一个变量count存放循环的次数，先分析count的值，再循环
	int count = ps->size;//这里要移动所有数据，那么进行size次
	for (int i = 0; i < count; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
		//不清楚的同学还可以假设第一次循环和最后一次循环来验证一下
		//第一次：ps->arr[0]=ps->arr[1];就是第二个元素的值赋值到第一个元素的位置
		//最后一次：i=count-1=ps->size-1;ps->arr[ps->size - 2]=ps->arr[ps->size - 1];就是第size个元素的值赋值到第size-1个元素的位置
	}
	//移动完后让实际元素的个数减一即可
	ps->size--;
}
//2.尾部删除数据
void SLPopTail(SL* ps)
{
	assert(ps);
	//尾部删除很简单，只需要将实际元素的个数-1即可，就访问不到了
	ps->size--;
}
🌵指定位置删除🌵 
//5.指定位置删除
void SLPop(SL* ps, int pos)
{
	assert(ps);
	//分析：指定位置删除，指定数据向前移动一位，从后向前会导致还未被移动的数据被覆盖掉，影响后续移动
	//		所以采用从前向后移动
	//这里给推荐大家一个方法：如果你不知道循环进行几次，先定义一个变量count存放循环的次数，先分析count的值，再循环
	//第1个元素前有0个元素，第3个元素前有2个元素，那么第pos个元素前就有pos-1个元素
	int count = ps->size - (pos - 1) - 1;//移动的是指定位置后的数据，那么不包括第pos个元素也要移动，就是总的减去第pos前的元素个数，再-1
	for (int i = 0; i < count; i++)
	{
		ps->arr[pos - 1 + i] = ps->arr[pos + i];
		//不清楚的同学还可以假设第一次循环和最后一次循环来验证一下
		//第一次：ps->arr[pos-2]=ps->arr[pos-1];就是第pos+1个元素的值赋值到第pos个元素的位置
		//最后一次：i=count-1=ps->size-pos-1;ps->arr[ps->size-2]=ps->arr[ps->size-1];就是第size个元素的值赋值到第size-1个元素后一个元素的位置
	}
	//移动完后让实际元素的个数减一即可
	ps->size--;
}
   🌵顺序表数据查找函数🌵

不同数据的类型，实现方法不同，这里顺序表的元素时int类型，那么只需要调用"=="比较值即可，而如果是结构体，那么比较方式可能就有几种不同的成员变量比较查找的方式

//顺序表的查找数据
void SLFind(SL* ps,SLDataType x)
{
	assert(ps);
	int n = 0;//计算找到的次数
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			n++;
			printf("找到了，为第%d个元素\n", i + 1);
		}
		if (i == ps->size - 1 && n==0)//如果最后一次还没有找到
			printf("没有找到\n");
	}
}

还有许多函数的实现，比如指定位置后插入，指定位置前删除，查找函数等等，请参考后面的源码

(3).源文件SeqList_test.c

测试顺序表的功能，一般是测试不同的函数就将封装在测试函数中，再在主函数中调用，这样代码的客观性更好。

int main()
{
	test1_SLPushHead();
	test2_SLPushTail();
	test3_SLPushFront();
	test4_SLPushBack();
	test5_SLPopHead();
	test6_SLPopTail();
	test7_SLPopFront();
	test8_SLPopBack();
	test9_SLPop();
	test10_SLFind();
	test11_SLModfiy();
}

具体函数内容参考下面的源码。

⚂源码分享

SeqList.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//先来定义一下顺序表的元素类型名
typedef int SLDataType;
//顺序表的定义
struct SeqList
{
	SLDataType* arr;//指向顺序表空间的地址
	int size;//顺序表实际元素个数
	int capacity;//顺序表的总容量
};
//顺序表创建的关键字太长了，重新命名一下
typedef struct SeqList SL;

//顺序表功能的定义

//顺序表的初始化和销毁
void SLInit(SL* ps);//对顺序表的实际值进行修改，不能传值，因为传值是对原顺序表的拷贝，修改的拷贝值
void SLDestroy(SL* ps);

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

//顺序表的内存大小的判断
void SLCheckCapacity(SL* ps);

//顺序表的插入数据
//1.头部插入数据
void SLPushHead(SL* ps,SLDataType x);
//2.尾部插入数据
void SLPushTail(SL* ps, SLDataType x);
//3.指定位置前插入数据
void SLPushFront(SL* ps,int pos,SLDataType x);
//4.指定位置后插入数据
void SLPushBack(SL* ps,int pos, SLDataType x);

//顺序表的删除数据
//1.头部删除数据
void SLPopHead(SL* ps);
//2.尾部删除数据
void SLPopTail(SL* ps);
//3.指定位置前删除数据
void SLPopFront(SL* ps,int pos);
//4.指定位置后删除数据
void SLPopBack(SL* ps,int pos);
//5.指定位置删除
void SLPop(SL* ps, int pos);

//顺序表的查找数据
void SLFind(SL* ps, SLDataType x);

//顺序表的修改数据
void SLModfiy(SL* ps,int pos,SLDataType);

SeqList.c

#include"SeqList.h"
//顺序表功能的实现
//顺序表的初始化和销毁
void SLInit(SL* ps)//对顺序表的实际值进行修改，不能传值，因为传值是对原顺序表的拷贝，修改的拷贝值
{
	assert(ps);//传指针就要断言一下，防止为空指针，后面都是如此
	//初始化可以选择设置有效初始大小和无效初始大小（NULL和0）
	//我们这里选择后者，不开辟初始空间
	ps->arr = NULL;//置为空，无初始空间
	ps->size = ps->capacity = 0;
}
void SLDestroy(SL* ps)
{
	assert(ps);
	if (ps->arr != 0)//空间有效才销毁，没有开辟空间就没必要销毁了
	{
		free(ps->arr);//销毁空间，防止内存泄漏
		ps->arr = NULL;//指针置为空，规避野指针
	}
	ps->size = ps->capacity = 0;//个数和容量置为初始状态的值
}

//顺序表的打印
void SLPrint(SL* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)//打印次数为size次，有多少个元素就打印多少个
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");//打印完换行
}

//顺序表的内存大小的判断
void SLCheckCapacity(SL* ps)
{
	//判断容量大小就是判断实际元素个数size和总容量的数目是否相等
	if (ps->size == ps->capacity)//如果相等就扩容2倍
	{
		//存在问题1：实际元素个数和容量大小可能等于0，那就是还没有开辟空间
		//使用三目操作符判断一下
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		//如果等于0，我们就将它设置为4，不等于就返回2倍的大小，同时使用新的容量变量接收
		//此时要扩容容量的数值就不为0了，可以开始扩容
		SLDataType* arr_tmp = (SLDataType*)realloc(ps->arr, newcapacity * sizeof(SLDataType));
		//realloc可能扩容失败，所以不直接使用ps->arr进行接收，会导致原空间起始地址丢失的情况
		if (arr_tmp == NULL)//判断是否失败
		{
			perror("realloc");//打印错误
			return;//扩容失败了，可以结束函数了
		}
		//扩容成功，新空间的地址赋值给存原空间的变量，新容量大小赋值给存旧容量大小的变量
		ps->arr = arr_tmp;
		ps->capacity = newcapacity;
	}
	//不相等就不要扩容
}

//顺序表的插入数据
//1.头部插入数据
void SLPushHead(SL* ps,SLDataType x)
{
	assert(ps);
	//插入数据前，判断空间是否足够
	SLCheckCapacity(ps);
	//保证足够后开始插入数据
	//分析：头部插入，所有数据向后移动一位，从前向后会导致还未被移动的数据被覆盖掉，影响后续移动
	//		所以采用从后向前移动
	//这里给推荐大家一个方法：如果你不知道循环进行几次，先定义一个变量count存放循环的次数，先分析count的值，再循环
	int count = ps->size;//这里要移动所有数据，那么进行size次
	for (int i = 0; i < count; i++)
	{
		ps->arr[ps->size - i] = ps->arr[ps->size - i - 1];
		//不清楚的同学还可以假设第一次循环和最后一次循环来验证一下
		//第一次：ps->arr[ps->size]=ps->arr[ps->size-1];就是最后一个元素的值赋值到后面一个元素的位置
		//最后一次：i=count-1=ps->size-1;ps->arr[1]=ps->arr[0];就是第一个元素的值赋值到第二个元素的位置
	}
	//移动完后就开始插入数据
	ps->arr[0] = x;//把第一个位置的值置为目标变量值x
	//插入一个数据后不要忘记实际元素个数+1
	ps->size++;
}
//2.尾部插入数据
void SLPushTail(SL* ps, SLDataType x)
{
	assert(ps);
	//插入数据前，判断空间是否足够
	SLCheckCapacity(ps);
	//保证足够后开始插入数据
	//分析：尾部插入不需要移动数据，直接在后面插入数据
	ps->arr[ps->size] = x;//下标为size的元素是第size+1个元素，下标和序号差-1，不知道的数组在内存中的存储就没学好
	//插入一个数据后不要忘记实际元素个数+1
	ps->size++;
}
//3.指定位置前插入数据
void SLPushFront(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	//插入数据前，判断空间是否足够
	assert(pos > 0 && pos <= ps->size);
	SLCheckCapacity(ps);
	//保证足够后开始插入数据
	//分析：头部插入，指定数据向后移动一位，从前向后会导致还未被移动的数据被覆盖掉，影响后续移动
	//		所以采用从后向前移动
	//这里给推荐大家一个方法：如果你不知道循环进行几次，先定义一个变量count存放循环的次数，先分析count的值，再循环
	//第1个元素前有0个元素，第3个元素前有2个元素，那么第pos个元素前就有pos-1个元素
	int count = ps->size - (pos - 1);//移动的是指定位置后的数据，那么包括第pos个元素也要移动，就是总的减去第pos前的元素个数
	for (int i = 0; i < count; i++)
	{
		ps->arr[ps->size - i] = ps->arr[ps->size - i - 1];
		//不清楚的同学还可以假设第一次循环和最后一次循环来验证一下
		//第一次：ps->arr[ps->size]=ps->arr[ps->size-1];就是最后一个元素的值赋值到后面一个元素的位置
		//最后一次：i=count-1=ps->size-pos;ps->arr[pos]=ps->arr[pos-1];就是第pos个元素的值赋值到第pos个元素后一个元素的位置
	}
	//此时第pos个元素(下标pos-1)的位置处没有数据，就插入给定数据x
	ps->arr[pos - 1] = x;
	//插入一个数据后不要忘记实际元素个数+1
	ps->size++;
}
//4.指定位置后插入数据
void SLPushBack(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	//插入数据前，判断空间是否足够
	SLCheckCapacity(ps);
	//保证足够后开始插入数据
	//分析：插入，指定数据向后移动一位，从前向后会导致还未被移动的数据被覆盖掉，影响后续移动
	//		所以采用从后向前移动
	//这里给推荐大家一个方法：如果你不知道循环进行几次，先定义一个变量count存放循环的次数，先分析count的值，再循环
	//第1个元素前有0个元素，第3个元素前有2个元素，那么第pos个元素前就有pos-1个元素
	int count = ps->size - pos;//移动的是指定位置后的数据，那么第pos个元素不需要移动，就是总的减去第pos+1前的元素个数
	for (int i = 0; i < count; i++)
	{
		ps->arr[ps->size - i] = ps->arr[ps->size - i - 1];
		//不清楚的同学还可以假设第一次循环和最后一次循环来验证一下
		//第一次：ps->arr[ps->size]=ps->arr[ps->size-1];就是最后一个元素的值赋值到后面一个元素的位置
		//最后一次：i=count-1=ps->size-pos - 1;ps->arr[pos+1]=ps->arr[pos];就是第pos+1个元素的值赋值到第pos+1个元素后一个元素的位置
	}
	//此时第pos个元素(下标pos-1)的后一个元素的位置处(下标pos)没有数据，就插入给定数据x
	ps->arr[pos] = x;
	//插入一个数据后不要忘记实际元素个数+1
	ps->size++;
}

//顺序表的删除数据
//1.头部删除数据
void SLPopHead(SL* ps)
{
	assert(ps);
	//分析：头部删除，所有数据向前移动一位，从后向前会导致还未被移动的数据被覆盖掉，影响后续移动
	//		所以采用从前向后移动
	//这里给推荐大家一个方法：如果你不知道循环进行几次，先定义一个变量count存放循环的次数，先分析count的值，再循环
	int count = ps->size;//这里要移动所有数据，那么进行size次
	for (int i = 0; i < count; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
		//不清楚的同学还可以假设第一次循环和最后一次循环来验证一下
		//第一次：ps->arr[0]=ps->arr[1];就是第二个元素的值赋值到第一个元素的位置
		//最后一次：i=count-1=ps->size-1;ps->arr[ps->size - 2]=ps->arr[ps->size - 1];就是第size个元素的值赋值到第size-1个元素的位置
	}
	//移动完后让实际元素的个数减一即可
	ps->size--;
}
//2.尾部删除数据
void SLPopTail(SL* ps)
{
	assert(ps);
	//尾部删除很简单，只需要将实际元素的个数-1即可，就访问不到了
	ps->size--;
}
//3.指定位置前删除数据
void SLPopFront(SL* ps,int pos)
{
	assert(ps);
	assert(pos > 1 && pos <= ps->size);
	//分析：指定位置前删除，指定数据向前移动一位，从后向前会导致还未被移动的数据被覆盖掉，影响后续移动
	//		所以采用从前向后移动
	//这里给推荐大家一个方法：如果你不知道循环进行几次，先定义一个变量count存放循环的次数，先分析count的值，再循环
	//第1个元素前有0个元素，第3个元素前有2个元素，那么第pos个元素前就有pos-1个元素
	int count = ps->size - (pos - 1);//移动的是指定位置后的数据，那么包括第pos个元素也要移动，就是总的减去第pos前的元素个数
	for (int i = 0; i < count; i++)
	{
		ps->arr[pos - 2 + i] = ps->arr[pos - 1 + i];
		//不清楚的同学还可以假设第一次循环和最后一次循环来验证一下
		//第一次：ps->arr[pos-2]=ps->arr[pos-1];就是第pos个元素的值赋值到第pos-1个元素的位置
		//最后一次：i=count-1=ps->size-pos;ps->arr[ps->size-2]=ps->arr[ps->size-1];就是第size个元素的值赋值到第size-1个元素后一个元素的位置
	}
	//移动完后让实际元素的个数减一即可
	ps->size--;
}
//4.指定位置后删除数据
void SLPopBack(SL* ps,int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	//分析：指定位置后删除，指定数据向后移动一位，从后向前会导致还未被移动的数据被覆盖掉，影响后续移动
	//		所以采用从前向后移动
	//这里给推荐大家一个方法：如果你不知道循环进行几次，先定义一个变量count存放循环的次数，先分析count的值，再循环
	//第1个元素前有0个元素，第3个元素前有2个元素，那么第pos个元素前就有pos-1个元素
	int count = ps->size - pos - 1;//移动的是指定位置后的数据，那么第pos个元素和第pos+1个元素不需要移动，就是总的减去第pos+1前的元素个数，再-1
	for (int i = 0; i < count; i++)
	{
		ps->arr[pos + i] = ps->arr[pos + 1 + i];
		//不清楚的同学还可以假设第一次循环和最后一次循环来验证一下
		//第一次：ps->arr[pos]=ps->arr[pos+1];就是第pos+2个元素的值赋值到第pos+1个元素的位置
		//最后一次：i=count-1=ps->size-pos - 2;ps->arr[ps->size-2]=ps->arr[ps->size-1];就是第size个元素的值赋值到第size-1个元素的位置
	}
	//移动完后让实际元素的个数减一即可
	ps->size--;
}
//5.指定位置删除
void SLPop(SL* ps, int pos)
{
	assert(ps);
	//分析：指定位置删除，指定数据向前移动一位，从后向前会导致还未被移动的数据被覆盖掉，影响后续移动
	//		所以采用从前向后移动
	//这里给推荐大家一个方法：如果你不知道循环进行几次，先定义一个变量count存放循环的次数，先分析count的值，再循环
	//第1个元素前有0个元素，第3个元素前有2个元素，那么第pos个元素前就有pos-1个元素
	int count = ps->size - (pos - 1) - 1;//移动的是指定位置后的数据，那么不包括第pos个元素也要移动，就是总的减去第pos前的元素个数，再-1
	for (int i = 0; i < count; i++)
	{
		ps->arr[pos - 1 + i] = ps->arr[pos + i];
		//不清楚的同学还可以假设第一次循环和最后一次循环来验证一下
		//第一次：ps->arr[pos-2]=ps->arr[pos-1];就是第pos+1个元素的值赋值到第pos个元素的位置
		//最后一次：i=count-1=ps->size-pos-1;ps->arr[ps->size-2]=ps->arr[ps->size-1];就是第size个元素的值赋值到第size-1个元素后一个元素的位置
	}
	//移动完后让实际元素的个数减一即可
	ps->size--;
}
//顺序表的查找数据
void SLFind(SL* ps,SLDataType x)
{
	assert(ps);
	int n = 0;//计算找到的次数
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			n++;
			printf("找到了，为第%d个元素\n", i + 1);
		}
		if (i == ps->size - 1 && n==0)//如果最后一次还没有找到
			printf("没有找到\n");
	}
}

//顺序表的修改数据
void SLModfiy(SL* ps,int pos,SLDataType x)
{
	assert(ps);
	ps->arr[pos - 1] = x;//pos-1就是第pos个元素的下标
}

SeqList_test.c

#include<stdio.h>
#include"SeqList.h"
void test1_SLPushHead()
{
	printf("****头部插入函数测试****\n");
	SL S;
	//初始化
	SLInit(&S);
	//头部插入数据
	SLPushHead(&S, 1);
	SLPushHead(&S, 2);
	SLPushHead(&S, 3);
	SLPushHead(&S, 4);
	//打印
	SLPrint(&S);
	//销毁
	SLDestroy(&S);
	printf("************************\n");
	printf("\n");
}
void test2_SLPushTail()
{
	printf("****尾部插入函数测试****\n");
	SL S;
	//初始化
	SLInit(&S);
	//尾部插入数据
	SLPushTail(&S, 1);
	SLPushTail(&S, 2);
	SLPushTail(&S, 3);
	SLPushTail(&S, 4);
	//打印
	SLPrint(&S);
	//销毁
	SLDestroy(&S);
	printf("************************\n");
	printf("\n");
}
void test3_SLPushFront()
{
	printf("****指定位置前插入函数测试****\n");
	SL S;
	//初始化
	SLInit(&S);
	//头部插入数据
	printf("插入数据：\n");
	SLPushHead(&S, 1);
	SLPushHead(&S, 2);
	SLPushHead(&S, 3);
	SLPushHead(&S, 4);
	//打印
	SLPrint(&S);
	printf("在第1个元素前插入数字8：\n");
	SLPushFront(&S, 1, 8);
	SLPrint(&S);
	printf("在第4个元素前插入数字10：\n");
	SLPushFront(&S, 5, 10);
	SLPrint(&S);
	//销毁
	SLDestroy(&S);
	printf("******************************\n");
	printf("\n");
}
void test4_SLPushBack()
{
	printf("****指定位置后插入函数测试****\n");
	SL S;
	//初始化
	SLInit(&S);
	//头部插入数据
	printf("插入数据：\n");
	SLPushHead(&S, 1);
	SLPushHead(&S, 2);
	SLPushHead(&S, 3);
	SLPushHead(&S, 4);
	//打印
	SLPrint(&S);
	printf("在第0个元素后插入数字8：\n");
	SLPushBack(&S, 0, 8);
	SLPrint(&S);
	printf("在第5个元素前插入数字10：\n");
	SLPushBack(&S, 5, 10);
	SLPrint(&S);
	//销毁
	SLDestroy(&S);
	printf("******************************\n");
	printf("\n");
}
void test5_SLPopHead()
{
	printf("****头部删除函数测试****\n");
	SL S;
	//初始化
	SLInit(&S);
	//头部插入数据
	printf("插入数据：\n");
	SLPushHead(&S, 1);
	SLPushHead(&S, 2);
	SLPushHead(&S, 3);
	SLPushHead(&S, 4);
	SLPushHead(&S, 5);
	SLPushHead(&S, 6);
	//打印
	SLPrint(&S);
	printf("头部删除1次：\n");
	SLPopHead(&S);
	SLPrint(&S);
	printf("头部删除2次：\n");
	SLPopHead(&S);
	SLPrint(&S);
	//销毁
	SLDestroy(&S);
	printf("******************************\n");
	printf("\n");
}
void test6_SLPopTail()
{
	printf("****尾部删除函数测试****\n");
	SL S;
	//初始化
	SLInit(&S);
	//头部插入数据
	printf("插入数据：\n");
	SLPushHead(&S, 1);
	SLPushHead(&S, 2);
	SLPushHead(&S, 3);
	SLPushHead(&S, 4);
	SLPushHead(&S, 5);
	SLPushHead(&S, 6);
	//打印
	SLPrint(&S);
	printf("尾部删除1次：\n");
	SLPopTail(&S);
	SLPrint(&S);
	printf("尾部删除2次：\n");
	SLPopTail(&S);
	SLPrint(&S);
	//销毁
	SLDestroy(&S);
	printf("******************************\n");
	printf("\n");
}
void test7_SLPopFront()
{
	printf("****指定位置前删除函数测试****\n");
	SL S;
	//初始化
	SLInit(&S);
	//头部插入数据
	printf("插入数据：\n");
	SLPushHead(&S, 1);
	SLPushHead(&S, 2);
	SLPushHead(&S, 3);
	SLPushHead(&S, 4);
	SLPushHead(&S, 5);
	SLPushHead(&S, 6);
	//打印
	SLPrint(&S);
	printf("删除第1个元素前的数据：\n");
	SLPopFront(&S,2);
	SLPrint(&S);
	printf("删除第5个元素前的数据：\n");
	SLPopFront(&S, 5);
	SLPrint(&S);
	//销毁
	SLDestroy(&S);
	printf("******************************\n");
	printf("\n");
}
void test8_SLPopBack()
{
	printf("****指定位置后删除函数测试****\n");
	SL S;
	//初始化
	SLInit(&S);
	//头部插入数据
	printf("插入数据：\n");
	SLPushHead(&S, 1);
	SLPushHead(&S, 2);
	SLPushHead(&S, 3);
	SLPushHead(&S, 4);
	SLPushHead(&S, 5);
	SLPushHead(&S, 6);
	//打印
	SLPrint(&S);
	printf("删除第0个元素后的数据：\n");
	SLPopBack(&S, 0);
	SLPrint(&S);
	printf("删除第3个元素后的数据：\n");
	SLPopBack(&S, 3);
	SLPrint(&S);
	//销毁
	SLDestroy(&S);
	printf("******************************\n");
	printf("\n");
}
void test9_SLPop()
{
	printf("****指定位置删除函数测试****\n");
	SL S;
	//初始化
	SLInit(&S);
	//头部插入数据
	printf("插入数据：\n");
	SLPushHead(&S, 1);
	SLPushHead(&S, 2);
	SLPushHead(&S, 3);
	SLPushHead(&S, 4);
	SLPushHead(&S, 5);
	SLPushHead(&S, 6);
	//打印
	SLPrint(&S);
	printf("删除第1个元素的数据：\n");
	SLPop(&S, 1);
	SLPrint(&S);
	printf("删除第5个元素后的数据：\n");
	SLPop(&S, 5);
	SLPrint(&S);
	//销毁
	SLDestroy(&S);
	printf("******************************\n");
	printf("\n");
}
void test10_SLFind()
{
	printf("****查找数据函数测试****\n");
	SL S;
	//初始化
	SLInit(&S);
	//头部插入数据
	printf("插入数据：\n");
	SLPushHead(&S, 1);
	SLPushHead(&S, 2);
	SLPushHead(&S, 3);
	SLPushHead(&S, 4);
	SLPushHead(&S, 5);
	SLPushHead(&S, 6);
	//打印
	SLPrint(&S);
	printf("查找值为1的数据：\n");
	SLFind(&S, 1);
	printf("查找值为5的数据：\n");
	SLFind(&S, 5);
	//销毁
	SLDestroy(&S);
	printf("******************************\n");
	printf("\n");
}
void test11_SLModfiy()
{
	printf("****修改指定位置数据函数测试****\n");
	SL S;
	//初始化
	SLInit(&S);
	//头部插入数据
	printf("插入数据：\n");
	SLPushHead(&S, 1);
	SLPushHead(&S, 2);
	SLPushHead(&S, 3);
	SLPushHead(&S, 4);
	SLPushHead(&S, 5);
	SLPushHead(&S, 6);
	//打印
	SLPrint(&S);
	printf("将第1个元素的数据修改为99：\n");
	SLModfiy(&S,1,99);
	SLPrint(&S);
	printf("将第6个元素的数据修改为66：\n");
	SLModfiy(&S, 6,66);
	SLPrint(&S);
	//销毁
	SLDestroy(&S);
	printf("******************************\n");
	printf("\n");
}
int main()
{
	test1_SLPushHead();
	test2_SLPushTail();
	test3_SLPushFront();
	test4_SLPushBack();
	test5_SLPopHead();
	test6_SLPopTail();
	test7_SLPopFront();
	test8_SLPopBack();
	test9_SLPop();
	test10_SLFind();
	test11_SLModfiy();
}

白日一万里
关注
专栏目录
算法与数据结构 --- 线性表 --- 顺序表示和实现
qq_51947882的博客
09-13 1133
list是线性表的英文名字，Elemset1. initialization 初始化2.销毁线性表的本质是将线性表从内存中删除3.置为空表的意思是将线性表中的元素全都删除1.数据元素判断函数的返回值类型是bool类型，当函数返回一个 true 时表示函数满足，返回一个false 时表示函数不满足2.这个函数会将我们传进来的 e 作为左参数，同时将 线性表中的每个元素依次作为右参数，左右参数进行比较，右参数依次变换，直到返回true为止，若比完了最后一个元素后仍无true则结束。
数据结构线性表--顺序表
11-17
使用软件为dev c++，使用c语言，用计算机类书籍《数据结构》中介绍的线性表中的顺序存储结构，建立了一个学生年龄表，可以实现基本的 插入 查找 删除 遍历，各个功能函数写有注释，方便阅读。
顺序表实现
weixin_56810796的博客
11-03 397
数据结构之顺序表实现
实现顺序表的各种基本运算的算法（超详细）
热门推荐
weixin_45959708的博客
08-08 1万+
//顺序表基本运算算法 #include <stdio.h> #include <malloc.h> #define MaxSize 50 typedef char ElemType; typedef struct { ElemType data[MaxSize]; //存放顺序表元素 int length; //存放顺序表的长度 } SqList; //顺序表的类型 void CreateList(SqList *&L,ElemType a[
顺序表基本运算的实现
weixin_30312563的博客
07-04 1172
1、建立顺序表 1 void CreateList(SqList*& L, ElemType a[], int n) 2 { 3 int i = 0, j = 0; 4 L = (SqList*)malloc(sizeof(SqList)); 5 while (i < n) 6 { 7 L->dat...
顺序表的基本运算的实现？
LOVE_Me__的博客
09-15 830
1.线性表的顺序存储又称为顺序表 2.顺序表必须占用一整块事先分配大小的固定的存储空间（一组地址连续的存储单元），依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻，所以进行插入或删除操作时，平均需要移动半个表的元素，这是相当费时的操作，不便于存储空间的管理。 下面我们来具体介绍顺训表具体运算的实现： #include&lt;stdio.h&gt; #include...
【数据结构篇】线性表1 --- 顺序表、链表 （万字详解！！）
iiiiiihuang的博客
09-03 2593
前言：这篇博客我们重点讲线性表中的顺序表、链表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
数据结构之线性表--顺序表的删除操作
ZHLCHLC的博客
08-08 1774
主要考察的是bool ListDelete(SeqList &L, int i, int &e)函数的使用 #include<stdio.h> using namespace std; #define MaxSize 10 typedef struct { int data[MaxSize]; int length; }SeqList; bool ListDelete(SeqList &L, int i, int &e) { if (i<1 ||
【数据结构篇C++实现】- 线性表 - 顺序表和链表
陈七的博客，学习知识分享，期待与大家的交流
03-20 3496
线性表知识总结，一文搞懂什么是顺序表与链表，以及常见的操作
线性表--顺序表与链表
Pert的博客
10-14 1033
物理结构是逻辑结构在计算机中的存储形式 数据的存储结构中的顺序存储结构能正确反映数据元素之间的逻辑关系，而链式存储结构不能 线性表 （1、线性表是具有（ 零个 ）或 （多个 ）数据元素的（ 有限 ）序列。 ** 线性表中数据元素之间的关系是（ 一对一 ）的关系，即除了第一个和最后一个数据元素之外，其他数据元素都是（ 首尾相连 ）的** （2、线性表的基本特征： ** 1、第一个数据元素没有前驱元素** ** 2、最后一个数据元素没有后继元素** ** 3、其余每个数据元素只有一个前驱元.
数据结构之线性表-顺序表的基本操作及其应用总结(带有详细注释及说明)
Carson's Blog
05-04 3049
顺序表的基本操作 顺序表的定义及初始化 /*顺序表的定义*/ #include <stdio.h> #include <malloc.h> #define MAX_SIZE 100 //数组最大长度 typedef int ElemType; //数据类型的别名 //定义线性表结构体 typedef struct sqlist { ElemType *data; //声明了一个名为data的长度不确定的数组，也叫“动态数组” int length; //记录
数据结构学习--线性表及其应用--顺序表
06-25
顺序表是将线性表中的元素顺序地存储在一块连续的内存空间里，通常采用数组作为其底层实现。这种存储方式具有随机访问的优势，因为可以通过元素的索引来直接访问数组中的任意位置。 在顺序表中，主要的操作包括初始...
2.C-数据结构-线性表-顺序表源码
08-30
2.C-数据结构-线性表-顺序表源码
c/c++数据结构-线性表-顺序表
04-26
数据结构实验中线性表的顺序表代码，带有详细注释，小白也能看得懂
【数据结构】线段树复杂应用
最新发布
2302_80811345的博客
09-13 1061
随着星际网络的进一步建设和规模的增大，一个新的问题出现在网络工程师面前——地址空间不够用了！原来，星际网络采用了传统的 IPv6 协议，虽然有2128级别的可用地址数量，但面对广袤无垠的宇宙和爆炸式增长的网络用户数，如此庞大的地址空间也面临了用尽的那一天。新的通信协议的研发工作交给了著名的网络科技圣地——西西艾弗星。最终，经过2333年的不懈努力，西西艾弗星的工程师们设计出了一种新的协议——“西西艾弗IP协议”，又称 IPxxaf。在 IPxxaf 协议中，一个地址由n位二进制位组成，其中。
数据结构---非线性--树
2301_80434764的博客
09-13 791
本文将详细介绍树及其变体在计算机科学中的应用及实现。首先，将概述树的基本概念、结构及其实际应用，包括树的表示方法及在各种应用场景中的重要性。接着，深入探讨二叉树的基本概念、特殊类型及其性质，并比较顺序存储和链式存储这两种主要存储结构。 在探讨二叉树的顺序结构及实现时，重点讲解堆的概念与结构，涵盖堆的向上和向下调整算法、建堆的时间复杂度以及堆的插入和删除操作，并讨论堆在排序和Top-K问题中的应用。最后，讨论二叉树的链式结构实现，包括各种遍历方式（如前序、中序、后序和层序遍历）和常见接口。
【数据结构】顺序表的定义和实现
m0_74209563的博客
09-13 574
顺序表是指用的方式实现线性表顺序存储：把的元素存储在的存储单元中，元素之间的关系由存储单元的邻接关系来体现【看到这是否会和我有同样的疑问：顺序表和数组是一样的吗？这个问题可以参考这篇文章的解释】
重头开始嵌入式第三十九天（数据结构 栈）
qq_64792908的博客
09-13 744
栈是一种数据结构，它具有以下特点：1. 只能在一端进行插入和删除操作，这一端被称为栈顶。2. 遵循“后进先出”（Last In First Out，LIFO）的原则。也就是说，最后进入栈的元素最先被弹出。3. 可以用数组或链表来实现。例如，把书一本一本叠放在桌子上，只能从最上面取书或放书，这就类似栈的操作。后放上去的书先被拿走，符合“后进先出”原则。
C语言-数据结构 弗洛伊德算法(Floyd)邻接矩阵存储
BamBoo_Bean的博客
09-13 652
C语言-数据结构 弗洛伊德算法(Floyd)邻接矩阵存储
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值