【数据结构】顺序表+经典算法OJ（零基础附完整代码）

原创 已于 2025-08-14 17:37:32 修改 · 1.1k 阅读 · 39 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#数据结构 #算法
于 2025-07-15 01:45:00 首次发布

目录

一、什么是顺序表？

1. 线性表

2. 顺序表的概念及结构

 二、顺序表的分类

1. 静态顺序表

2. 动态顺序表

三、动态顺序表的实现

1. 顺序表的初始化

2. 顺序表扩容

3. 顺序表的尾插

4. 顺序表的头插

 5. 顺序表的打印

6. 顺序表尾删

7. 顺序表头删

8. 顺序表指定位置插入

9. 顺序表指定位置删除

10. 查找

四、完整代码

五、顺序表经典算法

1. 移除元素

题目描述：

思路一：创建新数组

思路二：双指针法

代码实现

2. 合并两个有序数组

题目描述 ：

思路一：

思路二：创建三个指针

代码实现

一、什么是顺序表？

1. 线性表

线性表是具有相同特性的数据元素的有限序列，线性表是一种在实际中广泛使用的数据结构。常见的线性表：顺序表，链表，栈，队列...。线性表在逻辑结构上是线性结构，可以想象成一条直线；但在物理结构上不一定是连续的。

2. 顺序表的概念及结构

顺序表的底层结构是数组，所以顺序表的逻辑结构和物理结构和数组是一致的。只是顺序表是对数组的一个封装，顺序表在数组的基础上又增加了一些增删查改的接口。

对于数组arr，其逻辑结构是线性的，可以理解为一条直线；由于其在内存中占用连续的存储空间，且逻辑上相邻的元素在物理位置上也相邻，所以其物理结构（存储结构）是连续的。

 

对于顺序表，其底层结构为数组，所以逻辑结构是线性的，物理结构（存储结构 ）是连续的。

 二、顺序表的分类

1. 静态顺序表

静态顺序表即数组长度是给定的。

​//静态顺序表
#define N 10
//宏定义常量，便于修改操作
struct SeqList
{
	int arr[N];//定长数组
	int size;//有效数据个数
};

静态顺序表由于数组长度是固定的，因此，在工作场景中不够灵活。空间给少了不够用，空间给大了造成浪费 。所以静态顺序表存在很大的缺陷

2. 动态顺序表

 动态顺序表相比于静态顺序表，其空间是按需申请的，使用过程中更加灵活。因此，我们下面主要介绍动态顺序表各种功能的实现。

//动态顺序表
typedef int DateType;
typedef struct SeqList
{
	DateType* arr;
	int size;//有效数据个数
	int capacity;//空间容量
}SL;

 动态顺序表的优点就是，所需要的空间根据实际情况用realloc函数来扩容，不会造成空间浪费。

三、动态顺序表的实现

1. 顺序表的初始化

由于arr为指针，则初始化为NULL；size和capacity为整型变量，则初始化为0。

​//顺序表初始化
void InitSL(SL* ps)
{
	ps->arr = NULL;//指针设置为空
	ps->size = ps->capacity = 0;
}

2. 顺序表扩容

在下面的顺序表尾插，头插，指定位置插入操作中都需要判断当前数组的空间是否足够，当空间不足时，就需要对顺序表进行扩容操作。因此，我们单独将扩容的函数封装起来，在使用时直接调用来提高效率。

扩容其实就是要判断空间中的有效数据个数（ps->size）和空间容量大小（ps->capacity）是否相等。若相等，就需要扩容操作。

（1）先使用if语句判断size和capacity的大小是否相等；

（2）若相等，就扩容，但是又有两种不同的情况，我们用三目操作符来判断：

情况1：ps->size和ps->capacity均为0，此时给capacity增加4个空间。

情况2：ps->size和ps->capacity不为0，此时，capacity增加为原来的两倍。

（3）为了防止realloc函数申请空间失败而丢失数据，先用tmp记下扩容后空间的起始地址，判断tmp指针不为空之后再让arr指针指向tmp。

（4）将扩容后的newcapacity赋值给ps->capacity。

需要注意：当ps->size和ps->capacity相等且不为0时，我们在这里进行2倍扩容，这是一种对于空间处理较优的解决方式。如果大家感兴趣，可以搜索相关的证明。

代码展示

​//扩容
void ChechCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		//用三目操作符判断
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		//给数组arr调整空间大小
		DateType* tmp = (SL*)realloc(ps->arr, sizeof(DateType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newcapacity;
	}
}

3. 顺序表的尾插

（1）断言，防止传入空指针，无法对空指针进行解引用操作；

（2）想要尾插，数组就要有足够的空间，因此，在尾插之前我们需要先检查。而上面的顺序表扩容已经实现好了检查，同时，还调整了空间的大小，所以我们只需要调用上面的函数；

（3）将需要尾插的值插入，但是别忘了让有效数据个数size++。

代码展示如下

//顺序表的尾插
void SLPushBack(SL* ps, DateType x)
{
	//检查，防止传入空指针
	assert(ps);
	//调用扩容函数
	ChechCapacity(ps);
	ps->arr[ps->size++] = x;//赋值同时让size++
}

4. 顺序表的头插

头插的前面与尾插类似，但是，为了防止头插之后覆盖掉第一个数据，我们需要将数组中的元素整体往后移动一个位置。然后，赋值并让size++

代码如下

//顺序表的头插
void SLPushFront(SL* ps, DateType x)
{
	//断言
	assert(ps);
	ChechCapacity(ps);
	//将数组整体向后移动一个位置
	memmove(ps->arr + 1, ps->arr, ps->size * (sizeof(DateType)));
	ps->arr[0] = x;//赋值
	ps->size++;//有效数据加1
}

 5. 顺序表的打印

实现顺序表的打印，方便测试。

​//顺序表打印
void SLPrint(SL* ps,int sz)
{
	assert(ps);
	for (int i = 0; i < sz; i++)
	{
		printf("%d->", ps->arr[i]);
	}
}

运行结果

6. 顺序表尾删

尾删即在保证有效数据个数不为0的情况下，让有效数据个数减1。

代码如下

//顺序表的尾删
void SLPopback(SL* ps)
{
	assert(ps);
	assert(ps->size != 0);//针对ps->size为0
	ps->size--;//有效数据减1
}

7. 顺序表头删

头删可以让数组首元素后面的元素整体向前移动一个位置，用覆盖首元素的方式实现头删。

代码如下

//顺序表的头删
void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size != 0);
	memmove(ps->arr, ps->arr + 1, (--ps->size) * sizeof(DateType));//头删并--size（前置--，先减后用）
}

8. 顺序表指定位置插入

（1）断言：防止传空指针，同时，指定的位置要在数组下标范围之内；

（2）要插入数据，就要判断空间大小是否足够；

（3）将pos及之后的元素整体向后移动一个位置，防止插入的数据覆盖原来的数据；

（4）插入数据，size++

//在指定位置插入数据
void SLInsert(SL* ps, int pos,DateType x)
{
	assert(ps);
	//pos只能在下标范围之内
	assert(pos >= 0 && pos < ps -> size);
	//检查空间大小
	ChechCapacity(ps);
	//移动pos及之后的元素
	memmove(ps->arr + pos + 1, ps->arr + pos, (ps->size - pos) * sizeof(DateType));
	ps->arr[pos] = x;//插入
	ps->size++;//有效数据加1
}

9. 顺序表指定位置删除

//删除指定位置的数据
void SLEasert(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);

	memmove(ps->arr + pos, ps->arr + pos + 1, (ps->size - pos - 1) * sizeof(DateType));
	ps->size--;
}

10. 查找

遍历数组

//查找
int Find(SL* ps, DateType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
			return i;
	}
	return -1;
}

四、完整代码

（1）SeqList.h文件（头文件和函数声明）

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>

//静态顺序表
//#define N 10
//struct SeqList
//{
//	int arr[N];//定长数组
//	int size;//有效数据个数
//};

//动态顺序表
typedef int DateType;
typedef struct SeqList
{
	DateType* arr;
	int size;//有效数据个数
	int capacity;//空间容量
}SL;

//顺序表初始化
void InitSL(SL* ps);
//顺序表的销毁
void DestrySL(SL* ps);
//顺序表的尾插
void SLPushBack(SL* ps, DateType x);
//顺序表的头插
void SLPushFront(SL* ps, DateType x);
//顺序表的打印
void SLPrint(SL* ps,int sz);
//顺序表的尾删
void SLPopback(SL* ps);
//顺序表的头删
void SLPopFront(SL* ps);
//查找
int Find(SL* ps, DateType x);
//在指定位置插入数据
void SLInsert(SL* ps, int pos,DateType x);
//删除指定位置的数据
void SLEarse(SL* ps, int pos);

（2）SeqList.c文件（增删查改等实现代码）

#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"
//顺序表初始化
void InitSL(SL* ps)
{
	ps->arr = NULL;//指针设置为空
	ps->size = ps->capacity = 0;
}

//顺序表的销毁
void DestrySL(SL* ps)
{
	if (ps->arr)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

//扩容
void ChechCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		//用三目操作符判断
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		//给数组arr调整空间大小
		DateType* tmp = realloc(ps->arr, sizeof(DateType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newcapacity;
	}
}
//顺序表的尾插
void SLPushBack(SL* ps, DateType x)
{
	//检查，防止传入空指针
	assert(ps);
	//调用扩容函数
	ChechCapacity(ps);
	ps->arr[ps->size++] = x;//赋值同时让size++
}

//顺序表的头插
void SLPushFront(SL* ps, DateType x)
{
	//断言
	assert(ps);
	ChechCapacity(ps);
	//将数组整体向后移动一个位置
	memmove(ps->arr + 1, ps->arr, ps->size * (sizeof(DateType)));
	ps->arr[0] = x;//赋值
	ps->size++;//有效数据加1
}

//顺序表打印
void SLPrint(SL* ps,int sz)
{
	assert(ps);
	for (int i = 0; i < sz; i++)
	{
		printf("%d->", ps->arr[i]);
	}
}

//顺序表的尾删
void SLPopback(SL* ps)
{
	assert(ps);
	assert(ps->size != 0);//针对ps->size为0
	ps->size--;
}

//顺序表的头删
void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size != 0);
	memmove(ps->arr, ps->arr + 1, (--ps->size) * sizeof(DateType));//头删并--size（前置--，先减后用）
}

//查找
int Find(SL* ps, DateType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
			return i;
	}
	return -1;
}

//在指定位置插入数据
void SLInsert(SL* ps, int pos,DateType x)
{
	assert(ps);
	//pos只能在下标范围之内
	assert(pos >= 0 && pos < ps -> size);
	//检查空间大小
	ChechCapacity(ps);
	//移动pos及之后的元素
	memmove(ps->arr + pos + 1, ps->arr + pos, (ps->size - pos) * sizeof(DateType));
	ps->arr[pos] = x;//插入
	ps->size++;//有效数据加1
}

//删除指定位置的数据
void SLEasert(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	memmove(ps->arr + pos, ps->arr + pos + 1, (ps->size - pos - 1) * sizeof(DateType));
	ps->size--;
}

（3）test.c文件（测试代码）

#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"

//测试尾插，头插，打印
void test01()
{
	SL s;
	InitSL(&s);//初始化
	
	//尾插
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	
	////头插
	//SLPushFront(&s, 4);
	//SLPushFront(&s, 5);
	
	//尾删
	SLPopback(&s);
	//SLPopback(&s);
	//SLPopback(&s);
	
	//头删
	SLPopFront(&s);
	//SLPopFront(&s);
	//SLPopFront(&s);
	
	//打印
	SLPrint(&s, s.size);
}

void test02()
{
	SL s;
	InitSL(&s);//初始化
	//尾插
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	//指定位置插入
    SLInsert(&s, 1, 4);
	////指定位置删除
	//SLEasert(&s, 2);
	//打印
	SLPrint(&s, s.size);
}

int main()
{
	//test01();
	test02();
	return 0;
}

五、顺序表经典算法

1. 移除元素

题目描述：

给你一个数组 nums 和一个值 val，你需要移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。

思路一：创建新数组

创建一个新的数组，同时，创建一个变量 k 来记录与val 值不同的元素个数。然后遍历源数组，当源数组中的值不等于 val值时，将该值拿过来放到新数组中，并且k++。

思路二：双指针法

创建两个指针src和det，并且同时指向数组的第一个元素，即同时记录数组首元素的下标。然后，开始遍历数组，当数组元素等于val 值时，仅src++；反之，将src指向的元素赋值到det指向的位置，同时，src++，det++，k++。

该方法不开辟额外的空间。

代码实现
int removeElement(int* nums, int numsSize, int val) 
{
    int src=0;
    int det=0;
    int k=0;
    for(int i=0;i<numsSize;i++)
    {
        if(nums[i]==val)
        {
            src++;
        }
        else
        {
            nums[det++]=nums[src++];
            k++;
        }
    }
    return k;
}

2. 合并两个有序数组

题目描述 ：

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。题目提到不能开辟额外的空间。

思路一：

先将nums2数组中的所有元素先放到nums1数组的后面，然后，对nums1数组进行排序。

思路二：创建三个指针

创建三个指针s1，s2，s3，分别指向nums1的最后一个有效数据，nums2的最后一个有效数据以及nums1数组的最后，这样当我们遍历数组比较并赋值时，就不会出现将还没使用的数据覆盖掉的情况。如下图

然后，开始遍历两个数组。当s1指向元素大于或等于s2指向的元素时，将s1指向的元素拿过来放到s3指向的位置，同时，s1++，且s3++。一次操作如下图所示

但是，又有两种不同的情况。

情况一：s2 先出循环。如图，

此时，nums1中已经是合并好的数据，所以不用再做处理。

情况二：s1先出循环。如图，

 此时，nums2中的数据1并没有放到nums1中，因此，我们还需要做额外的处理，将剩下的数据放到nums1中。

代码实现
void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n)
{
    int s1=m-1;
    int s2=n-1;
    int s3=m+n-1;
    while(s1>=0&&s2>=0)
    {
        if(nums1[s1] >= nums2[s2])
        {
            nums1[s3--]=nums1[s1--];
        }
        else
        {
            nums1[s3--]=nums2[s2--];
        }
    }
    while(s2>=0)
    {
        nums1[s3--]=nums2[s2--];
    }
}

DS初阶：顺序表、链表相关OJ题（1）
热门推荐
weixin_51142926的博客
01-29 1万+
本文为经典算法OJ题练习，大部分题型都有多种思路，每种思路的解法博主都试过了（去网站那里验证）是正确的，大家可以参考！！
顺序表OJ（经典算法）——移除元素，合并数组
2301_80662522的博客
03-12 1860
学完了顺序表，我们来看看一些和顺序表算法相关的经典OJ题目今天分享的两道题目和顺序表的经典算法双指针法紧密相连，合并数组是双指针法的变形。在我们以后学习归并排序的时候，也是要用到双指针去合并数组和排序的。有第二道题的基础有利于我们更好地理解以后面对的归并排序，而第一题为我们提供的快慢指针法在不少OJ中也有它的影子，比如移动0问题，环形链表问题等等，我们会再次遇见。
【C语言—数据结构—算法题】顺序表、链表经典算法OJ题目
zhangzhiqi1100的博客
10-22 1170
先创建两个变量：src,dst，让这两个变量都指向数组首元素。如果src指向的值等于val，则src++，若不等于则将src的值赋给dst，然后src++，dst++。最后当src走到数组末尾时循环结束。
《数据结构初阶》【顺序表/链表 精选15道OJ练习】
序属秋秋秋的博客
05-01 2081
前面我们学习了数据结构中的顺序表和链表，现在你是不是苦于不知道如何练习巩固？又或者想刷题却不知从何下手？别担心！ 博主这里特地准备了 15道经典OJ练习题，涵盖顺序表和链表的各类操作，从基础到进阶，帮你一步步打通任督二脉！💪
算法与数据结构之Floyd算法
weixin_73953650的博客
06-20 445
超详细的Floyd算法教程，一看就懂！
多线程编程（一）
m0_62591054的博客
06-16 225
编译时：需加上 -lpthread，链接上对应的线程支持库。
Hermes Agent 技能进化系统拆解：Skill 的元数据结构、自注册加载与退化机制 [07]
Starry-SkyJing的博客
06-22 109
[07] Hermes Agent 技能进化系统拆解：Skill 的元数据结构、自注册加载与退化机制 > TL;DR：Skill 不是静态的文档——它是 Agent 的"程序性记忆"系统。SKILL
排序类...
qq_43519774的博客
06-22 225
└── 分配排序类 (核心：利用“多关键字”分配和收集，不依赖比较) ←── 这里补上你问的“基数排序”│ └── 堆排序 (利用堆结构选最值) ←── 这里补上你问的“选择排序”├── 选择排序类 (核心：在待排序列中选出最值，放到最终位置)├── 交换排序类 (核心：通过比较并交换元素位置来排序)├── 插入排序类 (核心：将元素插入到已有序的序列中)│ └── 希尔排序 (本质：多次分组插入排序)│ ├── 简单选择排序 (直接选最值)│ ├── 直接插入排序。
C/C++ 数据结构（十一）树
2301_80252792的博客
06-22 274
本文系统介绍了树结构基础与二叉树核心知识。主要内容包括：1.树的基础概念与术语（节点关系、度、深度等）；2.二叉树的数学特性、存储方式（链式/顺序）及堆结构；3.四种遍历算法（前/中/后序递归非递归实现，层序队列实现）；4.常用递归操作（求高、节点计数、插入删除）；5.应用实例（二叉搜索树、四/八叉树的游戏优化原理）。重点强调了完全二叉树与普通二叉树的区别，以及递归在树操作中的核心作用，为数据结构学习提供了完整框架。
算法与数据结构---二叉搜索树(BST)
MzKyle的博客
06-17 1399
二叉搜索树（BST）是一种基于二叉树的有序数据结构，核心特性是左子树节点值小于根节点，右子树节点值大于根节点。本文系统介绍了BST的核心概念与操作实现： 基本定义：BST通过"左小右大"的规则维护有序性，所有操作复杂度为O(h)，h为树高。平衡时h≈log₂n，退化为链表时h=n。 关键操作： 查找：根据值比较选择左右子树路径 插入：在适当位置创建新节点 删除：处理三种情况（无子节点、单子节点、双子节点），最复杂的是用中序前驱/后继替代被删节点 重要特性：中序遍历BST会得到有序序列，这是BST的核心性质。
数据结构基础复习——排序算法的关键代码片段
最新发布
2301_80025611的博客
06-22 306
针对数据结构考试中常见的代码填空题，我为你整理了上述核心排序算法的关键代码片段。考试时，出题人通常会挖空或。
Pulseaudio进阶开发之核心数据结构串联播放链路(三十)
Android系统攻城狮
06-22 461
本篇目的：Pulseaudio进阶开发之11个核心数据结构串联播放链路。
Redis 数据结构
土司先生的博客
06-22 237
redis 的 string , list 队列，Set 集，的数据结构讲解
C/C++ 数据结构（十）深搜广搜补充，A*算法
2301_80252792的博客
06-22 175
本文系统介绍了三种经典寻路算法： BFS广度优先搜索：基于队列实现分层扩散，天然保证最短路径，适用于迷宫寻路等场景，通过前驱数组回溯路径。 DFS深度优先搜索：递归实现栈结构，代码简洁但无法保证最优解，适合全图遍历，需注意栈溢出风险。 A*启发式算法：融合实际代价G与启发估值H（曼哈顿/欧式距离），通过Open/Close列表动态筛选路径，兼顾效率与最优性，是游戏和导航领域的工业标准。文中对比了三者特性，并给出完整代码框架及优化方向（如优先队列优化Open列表），突显A*在复杂场景下的综合优势。
【C++】数据结构之图的基本概念
L_0907的博客
06-17 276
本文系统介绍了并查集和图两种重要数据结构。并查集部分详细阐述了其基本概念、逻辑结构（森林表示）与物理存储（数组实现），重点讲解了路径压缩和按秩合并两种优化策略，并通过省份数量、等式方程等LeetCode题目展示了实际应用。图结构部分明确定义按秩合并顶点、边、有向/无向图等核心概念，比较了邻接矩阵和邻接表两种存储方式的优劣，给出了完整的C++实现代码。全文通过理论讲解结合代码实践，为后续学习图的遍历、最小生成树等算法奠定了坚实基础。
C/C++ 数据结构（九）深搜广搜
2301_80252792的博客
06-17 579
本文系统介绍了迷宫寻路算法的核心实现方法。重点分析了深度优先搜索(DFS)和广度优先搜索(BFS)两种算法，分别基于栈和队列实现。DFS采用"一条路走到底"的策略，适用于快速找到可行路径；BFS通过分层扩散确保找到最短路径。文章详细展示了两种算法的代码实现，包括迷宫表示、移动方向处理、越界判断等关键环节。同时探讨了路径记录、拾取所有金币等拓展场景，并比较了两种算法在时间复杂度、空间复杂度和适用场景上的差异。最后简要提及了A*算法等进阶内容，为游戏开发和路径规划提供了实用指导。
我的数据结构1
ChaoZiLL的博客
06-17 292
首先将数组的数据全部进行异或(^)操作，得到一个值a，再将该值与取负(原码取反+1)，得到(-a),将a与(-a)进行与(&)运算得到key值，key值就意味着该组数据中可以从右往左边数第几位为1，在使用key值作为分组的桥梁，是的同一组内的不同值再进行一次异或(^)操作，最后留下来的数就是需要的答案了；礼盒中除了一款撞色搭配的袜子，每种颜色的袜子均有两只。第一种：使用计数排序的思路从而找出缺失的数，但这样的空间复杂度是O(N)，因为要遍历数组，时间复杂度也是O(N)；的所有整数，但其中缺了一个。
ACM CSP竞赛笔记（七）——数据结构-栈与前中后缀表达式
2301_80226956的博客
06-20 199
栈在表达式计算中的应用，包括前缀、后缀表达式的计算方法
面经经验分享｜算法和数据结构考察
2501_94671711的博客
06-16 601
如大家所了解的，面试中考察的算法和数据结构。
【C++】数据结构之图的相关算法
L_0907的博客
06-17 415
本文系统地介绍了图的遍历算法以及相关算法。主要内容包括： BFS、DFS 及其实现。最小生成树算法： Kruskal算法、Prim算法，二者均基于贪心策略，得到全局最优解。最短路径算法： Dijkstra、Bellman-Ford、Floyd-Warshall 算法，并进行了三者的对比与实现。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值