【C语言数据结构】循环单链表

最新推荐文章于 2023-12-09 10:45:00 发布
最新推荐文章于 2023-12-09 10:45:00 发布
阅读量867 收藏
点赞数
分类专栏： 嵌入式软件

CircleLinkList.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#ifndef CIRCLE_LINK_LIST
#define CIRCLE_LINK_LIST
 
//链表节点
typedef  struct  _CircleLinkListNode
{
     struct  _CircleLinkListNode *next;
 
}CircleLinkListNode;
 
 
//循环单链表
typedef  void  CircleLinkList;
 
 
 
/*
  * 创建循环单链表
  * @return 返回循环单链表的指针
  */
CircleLinkList* CircleLinkList_Create();
 
/*
  * 销毁循环单链表
  * @param list 循环单链表的指针
  */
void  CircleLinkList_Destroy(CircleLinkList *list);
 
/*
  * 清空循环单链表
  * @param list 循环单链表的指针
  */
void  CircleLinkList_Clear(CircleLinkList *list);
 
/*
  * 向循环单链表pos位置处插入元素
  * @param list 循环单链表指针
  * @param node 元素指针
  * @param pos 插入的索引
  */
int  CircleLinkList_Insert(CircleLinkList *list,CircleLinkListNode *node, int  pos);
 
/*
  * 获取循环单链表中索引位置处的元素
  * @param list   循环单链表指针
  * @param pos   循环单链表索引值
  * @param return 元素指针
  */
CircleLinkListNode* CircleLinkList_Get(CircleLinkList *list, int  pos);
 
/*
  * 删除循环单链表中索引位置处的值
  * @param list 循环单链表的指针
  * @param pos   循环单链表索引
  * @param return 非0表示删除成功
  */
int  CircleLinkList_Remove(CircleLinkList *list, int  pos);
 
/*
  * 获取循环单链表当前已存储元素的个数
  * @param list 循环单链表的指针
  * @return 循环单链表中已存储元素的个数
  */
int  CircleLinkList_Length(CircleLinkList *list);
 
/*
  * 删除循环单链表中的特定元素
  * @param list 循环单链表的指针
  * @param pos   循环单链表元素指针
  * @param return 非0表示删除成功
  */
int  CircleLinkList_DeleteNode(CircleLinkList* list, CircleLinkListNode* node);
 
/*
  * 重置循环单链表中的游标，指向表头
  * @param list 循环单链表的指针
  * @return 返回游标指向的元素的指针
  */
CircleLinkListNode* CircleLinkList_Reset(CircleLinkList* list);
 
/*
  * 获取当前游标指向的元素指针
  * @param list 循环单链表的指针
  * @return 返回当前游标指向的元素指针
  */
CircleLinkListNode* CircleLinkList_Current(CircleLinkList* list);
 
/*
  * 移动当前游标到下一个元素
  * @param list 循环单链表的指针
  * @return 移动后的游标指向的元素的指针
  */
CircleLinkListNode* CircleLinkList_Next(CircleLinkList* list);
 
 
 
 
#endif // CIRCLECircleLinkList

CircleLinkList.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
#include "Circlelinklist.h"
#include <malloc.h>
 
//循环单链表
typedef  struct  _CircleLinkList
{
     CircleLinkListNode header; //链表头节点
     CircleLinkListNode* cursor; //游标
     int  length; //链表长度
 
}TCircleLinkList;
 
 
 
/*
  * 创建循环单链表
  * @return 返回循环单链表的指针
  */
CircleLinkList* CircleLinkList_Create()
{
     TCircleLinkList *list  = (TCircleLinkList *) malloc ( sizeof (TCircleLinkList));
 
     if (list != 0)
     {
         list->header.next = 0;
         list->length= 0;
     }
 
     return  list;
}
 
/*
  * 销毁循环单链表
  * @param list 循环单链表的指针
  */
void  CircleLinkList_Destroy(CircleLinkList *list)
{
     free (list);
}
 
/*
  * 清空循环单链表
  * @param list 循环单链表的指针
  */
void  CircleLinkList_Clear(CircleLinkList *list)
{
     if (list != 0)
     {
         TCircleLinkList *c_list = (TCircleLinkList *)c_list;
         c_list->header.next = 0;
         c_list->length = 0;
         c_list->cursor = 0;
     }
}
 
/*
  * 向循环单链表pos位置处插入元素
  * @param list 循环单链表指针
  * @param node 元素指针
  * @param pos 插入的索引
  */
int  CircleLinkList_Insert(CircleLinkList *list,CircleLinkListNode *node, int  pos)
{
     //类型转换
     TCircleLinkList* l_list = (TCircleLinkList *)list;
     //判断链表指针和节点指针不能为空,当前插入的位置是否合法
     int  ret = ((list != 0) && (node != 0) && (pos >= 0) && (pos <= l_list->length));
 
     if (ret)
     {
         CircleLinkListNode* current = (CircleLinkListNode *)l_list;
         int  i;
         //移动到需要插入的位置的前驱
         for (i = 0; i < pos;i++)
         {
             current = current->next;
         }
 
         node->next = current->next;    //被插入节点的后继指针指向前驱节点的后继指针
         current->next = node;          //前驱节点的后继指针指向被插入节点
 
         //如果插入的位置是0，则需要修改尾节点的后继指针
         if (pos == 0)
         {
             current = l_list->header.next;
             for (i = 0;i < l_list->length;i++)
             {
                 current = current->next;
             }
             current->next = node; //改变尾节点的指针
 
             //判断插入是否是空表
             if (l_list->length == 0)
             {
                 l_list->cursor = node;
                  node->next = node;
             }
         }
 
         l_list->length++;
 
     }
 
     return  ret;
}
 
/*
  * 获取循环单链表中索引位置处的元素
  * @param list   循环单链表指针
  * @param pos   循环单链表索引值
  * @param return 元素指针
  */
CircleLinkListNode* CircleLinkList_Get(CircleLinkList *list, int  pos)
{
     CircleLinkListNode* node = 0;
     TCircleLinkList * l_list = (TCircleLinkList *)list;
     //判断链表指针不为空，且获取的索引合法
     if ( (l_list != 0) && (pos >= 0))
     {
 
         CircleLinkListNode* current = (CircleLinkListNode *)l_list;
         int  i;
         for (i = 0; i < pos; i++)
         {
             current = current->next;
         }
         node = current->next;
     }
 
     return  node;
}
 
/*
  * 删除循环单链表中索引位置处的值
  * @param list 循环单链表的指针
  * @param pos   循环单链表索引
  * @param return 非0表示删除成功
  */
int  CircleLinkList_Remove(CircleLinkList *list, int  pos)
{
     TCircleLinkList * l_list = (TCircleLinkList *)list;
     int  ret = ((l_list != 0) && (pos >= 0) && (pos < l_list->length));
 
     if (ret)
     {
         CircleLinkListNode* current = (CircleLinkListNode *)list;
         CircleLinkListNode* first = l_list->header.next;
         CircleLinkListNode* last = (CircleLinkListNode*)CircleLinkList_Get(l_list, l_list->length - 1);
         CircleLinkListNode *del;
         int  i;
         for (i=0; i<pos; i++)
         {
             current = current->next;
         }
 
         del = current->next;
         current->next = del->next;
 
         l_list->length--;
 
         if ( first == del )
         {
             l_list->header.next = del->next;
             last->next = del->next;
         }
 
         if ( l_list->cursor == del )
         {
             l_list->cursor = del->next;
         }
 
         if ( l_list->length == 0 )
         {
             l_list->header.next = 0;
             l_list->cursor = 0;
         }
     }
 
     return  ret;
}
 
/*
  * 获取循环单链表当前已存储元素的个数
  * @param list 循环单链表的指针
  * @return 循环单链表中已存储元素的个数
  */
int  CircleLinkList_Length(CircleLinkList *list)
{
     int  ret = -1;
     if (list != 0)
     {
         TCircleLinkList * l_list = (TCircleLinkList *)list;
         ret = l_list->length;
     }
 
     return  ret;
}
 
 
/*
  * 删除循环单链表中的特定元素
  * @param list 循环单链表的指针
  * @param pos   循环单链表元素指针
  * @param return 被删除元素的索引
  */
int  CircleLinkList_DeleteNode(CircleLinkList* list, CircleLinkListNode* node)
{
     int  ret = -1;
 
     if ((list != 0) && (node != 0))
     {
         TCircleLinkList * l_list = (TCircleLinkList *)list;
         CircleLinkListNode* current = l_list->header.next;
         int  i;
         for (i = 0; i < l_list->length ;i++)
         {
             if (node == current)
             {
                 CircleLinkList_Remove(l_list,i);
                 ret = i;
                 break ;
             }
             current = current->next;
         }
     }
 
     return  ret;
}
 
/*
  * 重置循环单链表中的游标，指向表头
  * @param list 循环单链表的指针
  * @return 返回游标指向的元素的指针
  */
CircleLinkListNode* CircleLinkList_Reset(CircleLinkList* list)
{
     CircleLinkListNode *node = 0;
     if (list != 0)
     {
          TCircleLinkList * l_list = (TCircleLinkList *)list;
          l_list->cursor = l_list->header.next;
          node = l_list->cursor;
     }
 
     return  node;
}
 
/*
  * 获取当前游标指向的元素指针
  * @param list 循环单链表的指针
  * @return 返回当前游标指向的元素指针
  */
CircleLinkListNode* CircleLinkList_Current(CircleLinkList* list)
{
     CircleLinkListNode *node = 0;
     if (list != 0)
     {
          TCircleLinkList * l_list = (TCircleLinkList *)list;
          node = l_list->cursor;
     }
 
     return  node;
}
 
/*
  * 移动当前游标到下一个元素
  * @param list 循环单链表的指针
  * @return 移动后的游标指向的元素的指针
  */
CircleLinkListNode* CircleLinkList_Next(CircleLinkList* list)
{
     CircleLinkListNode *node = 0;
     if (list != 0)
     {
          TCircleLinkList * l_list = (TCircleLinkList *)list;
          l_list->cursor = l_list->cursor->next;
          node = l_list->cursor;
     }
 
     return  node;
}

测试代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include <stdio.h>
#include "Circlelinklist.h"
 
struct  Value
{
     CircleLinkListNode node;
     int  val;
};
 
int  main( void )
{
    struct  Value val[5];
    int  i;
    struct  Value *p;
 
 
    CircleLinkList *list = CircleLinkList_Create();
    for (i = 0;i < 5;i++)
    {
         val[i].val = i;
    }
 
    for (i = 0;i < 5;i++)
    {
        CircleLinkList_Insert(list,(CircleLinkListNode *)&(val[i]),0);
    }
 
  // CircleLinkList_DeleteNode(list,&(val[0]));
 
 
 
    for (i = 0;i < 6;i++)
    {
        p = CircleLinkList_Get(list,i);
        printf ( "%d\n" ,p->val);
        CircleLinkList_Next(list);
 
    }
 
    CircleLinkList_Reset(list);
    p = CircleLinkList_Get(list,0);
    printf ( "%d\n" ,p->val);
 
 
 
 
 
 
 
    return  0;
}

本文出自 “沃特” 博客，请务必保留此出处http://water3700348.blog.51cto.com/13058625/1965609


skyaizl
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言 数据结构 循环单链表的初始化、建立与遍历
m0_50614600的博客
02-13 515
循环单链表的初始化、建立与遍历 文章目录前言代码实现其他 前言 循环链表是另一种形式的链式存储结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。 代码实现 代码如下（示例）： #include <stdio.h> #include <stdlib.h> typedef struct CList{ int data; CList *next; }CList,*CLinkList; bool InitList(CLinkList &L){ L=
C语言实现的循环单链表功能示例
08-27
在C语言中，循环单链表可以定义为一个链表，其中每个节点都包含一个数据元素和一个指向下一个节点的指针。循环单链表的特点是最后一个节点的指针域指向第一个节点，从而形成一个环状结构。 二、循环单链表的创建 ...
C语言数据结构循环单链表,数据结构 C语言实现循环单链表的实例
weixin_39814378的博客
05-24 121
数据结构 C语言实现循环单链表的实例实例代码：//=========杨鑫========================////循环单链表的实现#include #include typedef int ElemType;//定义结点类型typedef struct Node{ElemType data;struct Node *next;}Node,*LinkedList;int count =...
C语言数据结构-单链表
来自计科大一萌新的编程记录本
01-02 354
C语言数据结构-单链表
3.数据结构C语言-循环单链表
static_diana的博客
10-30 323
主要涉及循环单链表的初始化、尾插建表和合并带头指针的循环单链表/*合并带尾指针的循环单链表*/操作，代码实现如下： /*头文件、循环单链表存储结构的描述和各种操作函数的声明*/ #include <stdio.h> #define ERROR 0 #define OK 1 typedef char ElemType; typedef struct CirculLinkList { ElemType data; struct CirculLinkList* next; }Node, *
数据结构——循环单链表【c语言版】
clear-ninghongkang的博客
11-19 2835
循环链表包括循环单链表和循环双链表 循环单链表的结点类型与非循环单链表相同，把非循环单链表改成循环单链表只需要将非循环单链表的尾结点next指针由原来的NULL改为指向头节点，自此就将非循环单链表形成看一个环，从表中的任一结点出发均可找到链表中其他的结点，这就是带头节点的循环单链表。 循环单链表的操作与单链表基本一致，差别在于遍历链表时，判别当前指针p是否指向表尾结点的终止条件不同： 单链表：p->next != NULL 循环单链表：p->next !=...
C语言数据结构_单链表应用（多项式相加）
qq_61726359的博客
05-05 1722
单链表的应用-多项式的相加 该代码的原理：首先创建两个链表tempList1和tempList2分别存放按照指数从小到大一定长度的数据。再申请五个指针p,q,r,s,temp指针p和q分别指向tempList1（tempList2)和tempList2(tempList1),s是free指数相同的结点，r将两个链表的结点相连以及连接free(s)结点的前后两个结点，按照我的代码首先p指向tempList1的第一个结点（头结点的下一个结点）q指向tempList2的第一个结点（头结点的下一个结点），然后进行结
C语言数据结构-基于单链表实现通讯录
m0_73678713的博客
12-09 1678
在Contact.h头文件中定义名字最大长度，性别最大长度，电话最大长度，地址最大长度120102050//前置声明//定义结构体int age;}ConInfo;
C语言数据结构单链表
临界三级管的博客
11-28 348
本文详细讲解了单链表的创建使用，以及一个用单链表做的简单图书管理系统。概述： 单链表是一种常见的线性数据结构，用于存储一系列元素。单链表中的每个元素被称为节点（Node），每个节点包含两个部分：数据域（存储数据）和指针域（指向下一个节点的指针）。
C语言数据结构——单链表(不带头)
qq_65980796的博客
02-13 2261
一、单链表：1.1 概念、1.2 链表结构分析、1.3 单链表的基本操作、1.4 单链表的基本操作源码。
数据结构之循环单链表（C语言附完整代码）
m0_62795460的博客
11-09 6849
循环单链表是单链表的另一种形式，其结构特点链表中最后一个结点的指针域不再是结束标记，而是指向整个链表的第一个结点，从而使链表形成一个环。示意图：声明循环单链表typedef struct LNode //定义单链表结点类型 {注意：本文章讨论的循环单链表是带头结点的循环单链表。增加头结点的优点如下：1.循环单链表中首结点的插入和删除操作与其他结点一致，无需进行特殊处理。2.无论循环单链表是否为空都有一个头结点，因此统一了空表和非空表的处理过程。
数据结构 C语言实现循环单链表的实例
08-30
数据结构 C语言实现循环单链表的实例 数据结构是计算机科学中的一门重要学科，它研究的是数据的存储、表示和操作的方法。在计算机科学中，数据结构是指数据的组织、存储和操作的方法。循环单链表是一种常见的数据...
C语言数据结构单链表的增删改查
05-27
在这个主题中，我们将深入探讨"单链表"这种基本的数据结构以及在C语言中如何进行增删改查的操作。 单链表是一种线性数据结构，其中的元素（节点）通过指向下一个元素的指针连接在一起。每个节点包含两部分：数据域...
C语言数据结构代码全套
03-04
本资源"‘C语言数据结构代码全套’"包含了用C语言实现的各种数据结构的完整代码，适合学生、程序员以及对数据结构感兴趣的自学者使用。 1. **数组**：数组是最基础的数据结构，它允许存储固定数量的同类型元素。在...
前端分析-202307110039
最新发布
07-29
前端分析-202307110039
Oracle中文基础PPT
07-29
Oracle中文基础PPT 虽然是10g，但是学习Oracle，10g版本没问题 Less01_DB_Architecture_MB3.ppt Less02_Installation_MB3.ppt Less03_DB_DBCA_MB3.ppt Less04_Instance_TB3.ppt Less05_Storage_TB3.ppt Less06_Users_MB3.ppt Less07_Schema_TB3.ppt Less08_Data_TB3.ppt Less09_Undo_TB3.ppt Less10_Security_MB3.ppt Less11_Network_MB3.ppt Less12_ProactiveM_MB3.ppt Less13_Performance_TB3.ppt Less14_BR_Concepts_MB3.ppt Less15_Backups_TB3.ppt Less16_R
【创新未发表】Matlab实现粒子群优化算法PSO-Kmean-Transformer-BiLSTM负荷预测算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
Java项目：基于SSM框架实现的公务员培训机构管理系统【ssm+B/S架构+源码+数据库+开题+任务书+毕业论文】
07-29
一、项目简介 本项目是一套基于SSM框架实现的公务员培训机构管理系统 包含：项目源码、数据库脚本等，该项目附带全部源码可作为毕设使用。 项目都经过严格调试，eclipse或者idea 确保可以运行！ 该系统功能完善、界面美观、操作简单、功能齐全、管理便捷，具有很高的实际应用价值 二、技术实现 jdk版本：1.8 及以上 ide工具：IDEA或者eclipse 数据库: mysql5.7 后端：spring+springmvc+mybatis+maven+mysql 前端：jsp，css，js 三、系统功能 系统登录角色包括管理员、考生、在职公务员 后台主要功能包括： 个人中心 修改密码 个人信息 在职公务员管理 考生管理 管理员信息 讲师管理 备考课程管理 基础数据管理 单位管理 公告类型管理 课程类型管理 在职培训课程管理 公告管理 轮播图管理等功能 前台主要功能包括： 用户登录 用户注册 首页 备考课程展示 课程详情 立即预订 讲师展示 公告信息 个人中心 备考课程预订 在职培训课程预订 余额充值 在职培训课程 跳转到后台等功能
Auto.js应用管理大师：自动化安装与卸载的艺术
07-29
Auto.js 是一个基于 JavaScript 的自动化脚本工具，主要用于 Android 平台。它允许用户编写脚本来自动执行一系列操作，如模拟点击、滑动、输入文本、读取和设置系统设置等。Auto.js 的目标是简化 Android 设备上的自动化任务，让用户能够通过编写脚本来实现自定义的自动化流程。 以下是 Auto.js 的一些主要特点： 1. **跨平台**：虽然主要针对 Android，但 Auto.js 也可以在其他支持 JavaScript 运行环境的平台上使用。 2. **易学易用**：如果你熟悉 JavaScript，那么学习 Auto.js 会相对容易，因为它使用类似的语法。 3. **丰富的API**：Auto.js 提供了丰富的 API，可以访问设备的许多功能，如文件系统、剪贴板、通知、网络等。 4. **社区支持**：Auto.js 拥有一个活跃的社区，用户可以在社区中分享脚本、解决问题和获取帮助。 5. **可扩展性**：用户可以根据自己的需要编写和分享自定义模块，以扩展 Auto.js 的功能。 6. **自动化任务**：Auto.js 可以用来自动化
数据结构循环单链表C语言上机操作
06-13
循环单链表是链表的一种特殊形式，它的特点是链表中的最后一个节点的指针指向第一个节点，形成一个闭合的环。在C语言中，操作循环单链表通常涉及创建、插入、删除和遍历等基本操作。 以下是一些基本操作的C语言实现概览： 1. **创建循环链表**: - 定义节点结构体，包含数据域和指向下一个节点的指针（如果是在头结点的最后一个节点，指针会指向自身）。 - 创建链表时，可以初始化一个头节点，然后递归地添加新节点到链尾。 ```c struct Node { int data; struct Node* next; }; // 创建循环链表 void createCircularList(struct Node** head, int size, ...) { ... } ``` 2. **插入节点**: - 可以在链表的头部、尾部或指定位置插入节点。 - 在头部插入，更新头节点的next；在尾部插入，找到当前尾节点，然后更新其next指向新节点，并将新节点next指向头节点。 ```c void insertNode(struct Node** head, int data, insertionPosition) { struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); newNode->data = data; newNode->next = (insertionPosition == 1) ? head : (*(head)->next); // 如果在尾部插入，更新尾节点和头节点的next指针 if (insertionPosition == 0) { (*head)->next = newNode; } } ``` 3. **删除节点**: - 删除某个节点时，需要找到前一个节点，然后更新其next指针跳过要删除的节点。 - 在循环链表中删除特定位置的节点需要特别处理头节点的情况。 ```c void deleteNode(struct Node** head, int position) { if (position == 1) { // 删除头节点 struct Node* temp = head->next; *head = temp; free(head); } else { struct Node* current = *head, *previous = NULL; for (int i = 1; i < position && current != NULL; ++i) { previous = current; current = current->next; } if (current == NULL) return; // 未找到节点 previous->next = current->next; } } ``` 4. **遍历循环链表**: - 使用while循环，每次迭代都更新当前节点指向下一个节点，直到遇到第一个节点。 ```c void printList(struct Node* head) { struct Node* temp = head; do { printf("%d ", temp->data); temp = temp->next; } while (temp != head); } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值