C语言数据结构循环链表

已于 2023-10-27 19:07:14 修改
阅读量71 收藏
点赞数
文章标签： 链表 数据结构
于 2023-10-15 12:54:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HandsomeYongYong/article/details/133839699
版权

循环链表的定义

循环链表是一种链表数据结构，与标准链表不同之处在于，循环链表的最后一个节点指向第一个节点，形成一个环状结构。

循环链表通常包括结点、头指针，以及循环特性。在遍历时，可以持续前进直到访问完所有节点。这种结构常用于需要循环遍历一组数据的情况，如循环队列或循环播放列表。在代码中，要确保节点和头指针正确连接以形成循环。

循环链表的特点

  1. 环状结构：最后一个节点指向第一个节点，形成一个环，可无限循环遍历。

  2. 动态扩展：适用于动态大小需求，不限制链表长度。

  3. 循环遍历便利：遍历操作方便，无需终止点。

  4. 插入和删除复杂：插入和删除节点需小心操作，牵涉前一节点指针的调整

循环链表的运算 

  1. 初始化：创建一个空的循环链表，通常将头指针指向NULL。

  2. 插入：在链表中插入新节点，可以是在链表头部、尾部或指定位置插入。插入操作需要考虑前一节点的指针调整，以保持环状结构。

  3. 删除：从链表中删除指定节点。删除操作也需要考虑前一节点的指针调整，以确保环状结构的完整性。

  4. 遍历：从头节点开始沿着"下一个"指针遍历整个链表，直到回到头节点为止。这使得可以循环遍历链表中的所有节点。

  5. 查找：查找链表中的特定节点，可以是根据节点值或位置查找。

  6. 判断空和满：检查循环链表是否为空或已满。

  7. 扩容：如果链表支持动态大小，可以实现扩容操作，以增加链表的容量。

循环链表的实现

定义链表

typedef int DataType;

/*简单链表的定义*/
typedef struct node
{
	DataType		data;	/*数据域*/
	struct node		*next;	/*指针域*/
}SingleLinkList, SingleLinkNode;

初始化链表

/*1. 初始化*/
int init(SingleLinkList **Head)
{
	if(1)
	{
		/*申请内存*/
		(*Head) = (SingleLinkList*)malloc(sizeof(SingleLinkList));
		/*判断内存申请是否成功*/
		if(*Head == NULL)
		{
			printf("申请内存错误， 初始化失败！[100001]\n");
			return 100001;
		}
		(*Head)->next = *Head;
		/*循环链表*/
		/*
			(*Head)->next = *Head;
		*/
		return 0;
	}
	else
	{
		printf("该链表已经初始化！请删除后再执行此操作！[100002]\n");
		return 100002;
	}
}

插入元素

/*2. 插入元素,头插法*/
int insert_head(SingleLinkList **Head, DataType x)
{
	SingleLinkNode *newNode;

	if(0)
	{
		printf("链表未初始化！[100003]\n");
		return 100003;
	}
	
	newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
	if(!newNode)
	{
		printf("申请节点内存空间失败！[100004]\n");
		return 100004;
	}
	newNode->data = x;
	newNode->next = (*Head)->next;

	(*Head)->next = newNode;

	return 0;
}


/*2. 插入元素， 尾插法*/
int insert_tail(SingleLinkList **Head, DataType x)
{
	SingleLinkNode *newNode;
	SingleLinkNode *p;

	if(0)
	{
		printf("链表未初始化！[100003]\n");
		return 100003;
	}
	
	newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
	if(!newNode)
	{
		printf("申请节点内存空间失败！[100004]\n");
		return 100004;
	}

	newNode->data = x;
	newNode->next = *Head;
	/*
	  循环链表
	  newNode->next = *Head;
	*/

	p = (*Head);

	while(p->next!=*Head)
	{
		p = p->next;
	}

	p->next = newNode;

	return 0;
}


/*2. 插入元素，在位置i处插入元素x */
int insert(SingleLinkList **Head, int i, DataType x)
{
	int j;
	SingleLinkNode *p;
	SingleLinkNode *newNode;

	
	/*对i进行判断，0<i<=length+1*/
	if(i<1 || i>length(*Head)+1)
	{
		printf("位置i不是链表有效位置！[100005]\n");
		return 100005;
	}
	p = (*Head);
	j = 1;

	while(j<i)
	{
		j++;
		p = p->next;
	}

	newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
	/*此处省略检测newNode是否申请成功*/

	newNode->data = x;
	newNode->next = p->next;
	p->next = newNode;
	return 0;
}

删除元素

int delete(SingleLinkList **Head, DataType x)
{
	int i;
	int j;

	SingleLinkNode *p;
	SingleLinkNode *q; /*要删除的元素x*/

	i = find(*Head,x);
	if(!i)
	{
		printf("元素x【%d】不存在！100006\n", x);
		return 100006;
	}
	
	p = (*Head);
	j=1;

	while(j<i)
	{
		j++;
		p = p->next;
	}
	
	q = p->next;
	p->next = q->next;

	free(q); /*释放内存*/

	return 0;
}

 查找元素

int find(SingleLinkList *Head, DataType x)
{
	int i;
	SingleLinkNode *p;

	i = 1;
	p = Head->next;

	while(p!=Head && p->data != x)  /*while( p!= Head && p->data != x) */
	{
		i++;
		p = p->next;
	}

	if(p==Head)  /* if(p->next == Head) */
	{
		return 0;
	}
	else
	{
		return i;
	}

}

输出链表长度

int length(SingleLinkList *Head)
{
	int len=0;
	SingleLinkNode *p;

	p = Head->next;
	while(p!=Head)	/* while(p!=Head) */
	{
		len++;
		p = p->next;
	}
	return len;
}

 输出链表

void print(SingleLinkList *Head)
{
	SingleLinkNode *p;
	int i=0;

	p = Head->next;
	if(p==Head)				/*  if(p!=Head)  */
	{
		printf("链表为空！\n");
		return;
	}
	while(p!=Head)  /* while(p!=Head)  */
	{
		printf("Node[%d]. = %d\n", ++i, p->data);
		p = p->next;
	}
}

运行结果截图 

完整Demo

main.c

#include <stdio.h>
#include <string.h>
#include "SingleLinkList.c"
#include "welcome.h"

int main(int argc, char *argv[])
{
	SingleLinkList *Head;
	DataType x;
	int i, m, n, cmd;

	for (i = 0; i < strlen(welcome); i++)
	{
		printf("%c", welcome[i]);
		for (m = 0; m < 2000; m++)
			for (n = 0; n < 2000; n++)
			{
				;
			}
	}

	printf("-----------简单链表演示程序----------\n");
	do
	{
		printf("1. 初始化链表表\n");
		printf("2. 插入元素（头插法）\n");
		printf("3. 插入元素（尾插法）\n");
		printf("4. 插入元素（在位置i插入）\n");
		printf("5. 查找元素x\n");
		printf("6. 求链表长度\n");
		printf("7. 输出链表\n");
		printf("8. 删除元素\n");
		printf("10. 帮助\n");
		printf("0. 退出\n");
		printf("请输入您要进行的操作（1~6,0退出）：");
		scanf("%d", &cmd);
		switch (cmd)
		{
		case 1:
			if (!init(&Head))
			{
				printf("链表已初始化！\n");
			}
			break;
		case 2:
			printf("请输入插入元素x：x=");
			scanf("%d", &x);
			if (!insert_head(&Head, x))
			{
				printf("元素（%d）已插入\n", x);
			}
			break;
		case 3:
			printf("请输入插入元素x：x=");
			scanf("%d", &x);
			if (!insert_tail(&Head, x))
			{
				printf("元素（%d）已插入\n", x);
			}
			break;
		case 4:
			printf("请输入插入元素位置i：");
			scanf("%d", &i);
			printf("请输入插入元素x：");
			scanf("%d",&x);
			if (!insert(&Head, i, x))
			{
				printf("已在位置（%d）插入元素（%d）！\n", i, x);
			}
			break;
		case 5:
			printf("请输入要查找的元素x：");
			scanf("%d", &x);
			if (i = find(Head, x))
			{
				printf("元素%d存在，在链表位置%d.\n", x, i);
			}
			else
			{
				printf("在链表中未找到元素x。\n");
			}
			break;
		case 6:
			printf("链表的长度为：%d\n", length(Head));
			break;
		case 7:
			print(Head);
			break;
		case 8:
			printf("请输入要删除的元素x：");
			scanf("%d", &x);
			if (!delete (&Head, x))
			{
				printf("元素x【%d】已删除!\n", x);
			}
			break;
		case 10:
			printf(" 本程序为链表的演示程序，由陈勇豪设计开发，程序完成了环形链表功能！\n");
			break;
		}
	} while (cmd != 0);

	return 0;
}

SingleLinkList.c

/*
	SingleLinkList.c
	
*/
#include "SingleLinkList.h"
#include <stdlib.h>
#include <stdio.h>

/*1. 初始化*/
int init(SingleLinkList **Head)
{
	if(1)
	{
		/*申请内存*/
		(*Head) = (SingleLinkList*)malloc(sizeof(SingleLinkList));
		/*判断内存申请是否成功*/
		if(*Head == NULL)
		{
			printf("申请内存错误， 初始化失败！[100001]\n");
			return 100001;
		}
		(*Head)->next = *Head;
		/*循环链表*/
		/*
			(*Head)->next = *Head;
		*/
		return 0;
	}
	else
	{
		printf("该链表已经初始化！请删除后再执行此操作！[100002]\n");
		return 100002;
	}
}


/*2. 插入元素,头插法*/
int insert_head(SingleLinkList **Head, DataType x)
{
	SingleLinkNode *newNode;

	if(0)
	{
		printf("链表未初始化！[100003]\n");
		return 100003;
	}
	
	newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
	if(!newNode)
	{
		printf("申请节点内存空间失败！[100004]\n");
		return 100004;
	}
	newNode->data = x;
	newNode->next = (*Head)->next;

	(*Head)->next = newNode;

	return 0;
}


/*2. 插入元素， 尾插法*/
int insert_tail(SingleLinkList **Head, DataType x)
{
	SingleLinkNode *newNode;
	SingleLinkNode *p;

	if(0)
	{
		printf("链表未初始化！[100003]\n");
		return 100003;
	}
	
	newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
	if(!newNode)
	{
		printf("申请节点内存空间失败！[100004]\n");
		return 100004;
	}

	newNode->data = x;
	newNode->next = *Head;
	/*
	  循环链表
	  newNode->next = *Head;
	*/

	p = (*Head);

	while(p->next!=*Head)
	{
		p = p->next;
	}

	p->next = newNode;

	return 0;
}


/*2. 插入元素，在位置i处插入元素x */
int insert(SingleLinkList **Head, int i, DataType x)
{
	int j;
	SingleLinkNode *p;
	SingleLinkNode *newNode;

	
	/*对i进行判断，0<i<=length+1*/
	if(i<1 || i>length(*Head)+1)
	{
		printf("位置i不是链表有效位置！[100005]\n");
		return 100005;
	}
	p = (*Head);
	j = 1;

	while(j<i)
	{
		j++;
		p = p->next;
	}

	newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
	/*此处省略检测newNode是否申请成功*/

	newNode->data = x;
	newNode->next = p->next;
	p->next = newNode;
	return 0;
}


/*3. 删除元素, 删除值为x的元素*/
int delete(SingleLinkList **Head, DataType x)
{
	int i;
	int j;

	SingleLinkNode *p;
	SingleLinkNode *q; /*要删除的元素x*/

	i = find(*Head,x);
	if(!i)
	{
		printf("元素x【%d】不存在！100006\n", x);
		return 100006;
	}
	
	p = (*Head);
	j=1;

	while(j<i)
	{
		j++;
		p = p->next;
	}
	
	q = p->next;
	p->next = q->next;

	free(q); /*释放内存*/

	return 0;
}


/*5. 查找值为x的元素，返回位置i */
int find(SingleLinkList *Head, DataType x)
{
	int i;
	SingleLinkNode *p;

	i = 1;
	p = Head->next;

	while(p!=Head && p->data != x)  /*while( p!= Head && p->data != x) */
	{
		i++;
		p = p->next;
	}

	if(p==Head)  /* if(p->next == Head) */
	{
		return 0;
	}
	else
	{
		return i;
	}

}

/*4. 链表长度*/
int length(SingleLinkList *Head)
{
	int len=0;
	SingleLinkNode *p;

	p = Head->next;
	while(p!=Head)	/* while(p!=Head) */
	{
		len++;
		p = p->next;
	}
	return len;
}

/*6.输出链表*/
void print(SingleLinkList *Head)
{
	SingleLinkNode *p;
	int i=0;

	p = Head->next;
	if(p==Head)				/*  if(p!=Head)  */
	{
		printf("链表为空！\n");
		return;
	}
	while(p!=Head)  /* while(p!=Head)  */
	{
		printf("Node[%d]. = %d\n", ++i, p->data);
		p = p->next;
	}
}

SingleLinkList.h

/*SingleLinkList.h*/

typedef int DataType;

/*简单链表的定义*/
typedef struct node
{
	DataType		data;	/*数据域*/
	struct node		*next;	/*指针域*/
}SingleLinkList, SingleLinkNode;


/*1. 初始化*/
int init(SingleLinkList **Head);

/*2. 插入元素,头插法*/
int insert_head(SingleLinkList **Head, DataType x);

/*2. 插入元素， 尾插法*/
int insert_tail(SingleLinkList **Head, DataType x);

/*2. 插入元素，在位置i处插入元素x */
int insert(SingleLinkList **Head, int i, DataType x);

/*3. 删除元素, 删除值为x的元素*/
int delete(SingleLinkList **Head, DataType x);

/*5. 查找值为x的元素，返回位置i */
int find(SingleLinkList *Head, DataType x);

/*6. 求链表的长度 */
int length(SingleLinkList *Head);

/*7.输出链表*/
void print(SingleLinkList *Head);

welcome.h 

char welcome[] = "\n\
                               \n\                      
                                  IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII\n\                              
                                  IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII\n\                              
                                  IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII\n\                              
                                  IIIII    IIIIIIIIIII     IIIIIII\n\                              
                                  IIIIIII     IIIIIIIIII   IIIIIII\n\                              
                                  IIIIIIIII     IIIIIIIIIIIIIIIIII\n\                              
                                  IIIIIIIIIII       IIIIIIIIIIIIII\n\                              
                                  IIIIIIIIIIIII        IIIIIIIIIII\n\                              
                                  IIIIIIIIIIIIIII         IIIIIIII\n\                              
                                  IIIIIIIIIIIIIIIII         IIIIII\n\                              
                                  IIIII    IIIIIIIIIII        IIII\n\                              
                                  IIIII     IIIIIIIIIII      IIIII\n\                              
                                  IIIII      IIIIIIIIIII    IIIIII\n\                              
                                  IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII\n\                              
                                  IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII\n\n\n\                                                                                                               
      IIIIIIIII.           .IIIIIIIII.       IIIIIIIIIIIII          I            .IIIIIII.\n\      
      III      III        III       III      I.   III   .I         III          III    III\n\      
      III       III      III         III          III             II II               III\n\       
      III        III     III          II          III            II  III             III\n\        
      III        III     III          II          III           II    III           III\n\         
      III       III       III        II           III          II      III         III\n\          
      III      II          IIII     II            III          IIIIIIIIIII        III    .I\n\     
      IIIIIIIIII             IIIIIII              III          II       II       IIIIIIIIII\n\n";

小结 

链表是一种基本的数据结构，它由节点组成，每个节点通常包含数据（例如整数或其他类型）和指向下一个节点的指针。每个节点包含数据和指向下一个节点的引用。链表的核心操作包括在特定位置插入或删除节点。这需要小心调整节点的指针。循环链表的最后一个节点指向第一个节点，使得链表可以无限循环遍历，适用于需要连续循环操作的情况。总之，链表是一种灵活的数据结构，适用于各种动态数据管理需求，但需要小心处理节点指针以维护链表的完整性。

参考文献：《数据结构（C语言版）》李刚、刘万辉主编，高等教育出版社。OpenAI

那一日的约定
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C语言循环链表
you__know的专栏
11-13 723
//声明下，这是一个循环链表，只实现了循环链表的创建以及遍历 //可供初学者学习 #include #include typedef struct node //定义一个结构体 { int data; struct node *next; }Node; Node *create(int a) //创建一个循环链表，并返回它的头指针。 { N
双向链表和循环链表
berniebd的专栏
09-03 1350
一、循环链表循环链表是与单链表一样，是一种链式的存储结构，所不同的是，循环链表的最后一个结点的指针是指向该循环链表的第一个结点或者表头结点，从而构成一个环形的链。循环链表的运算与单链表的运算基本一致。所不同的有以下几点：1、在建立一个循环链表时，必须使其最后一个结点的指针指向表头结点，而不是象单链表那样置为NULL。此种情况还使用于在最后一个结点后插入一个新的结点。 2、在判断是否到表尾时，是判断
C语言 单链表
SunNang的博客
11-11 404
代码 /* Note:Your choice is C IDE */ #include "stdio.h" #include "stdlib.h" //结点结构体 typedef struct n { //数据域 union { char d[20]; int len; }; struct n *next;//指针域 }list; //创建头结点 list *cj() { list *h=malloc(sizeof(list));//申请内存0; if(h!=NULL)
循环链表（C语言)
weixin_54454406的博客
10-15 216
注意：我们需要首先创建一个新的节点，然后调整节点的指针以适应新的链表结构。否则，将其添加到尾节点的后面，并更新尾节点为新节点。当插入新节点时，利用头节点的指针域始终指向头节点的后继节点的特点，来对新插入的节点完成前驱后继节点的设置。1.4：删除指定节点：前一个节点的 next 指针指向当前节点的下一个节点，从而删除当前节点。1.5：查找指定值：遍历链表中的每个节点，如果节点的数据等于目标值，就返回该节点在链表中的位置。头和尾插法建立：在循环链表的尾部或指定位置插入一个新的节点，更新后继指针和头节点指针。
循环链表（c语言版）
瑞_板凳精神
03-13 305
#include<stdio.h> #include<malloc.h> #include<string.h> #include<stdlib.h> #include<windows.h> typedef struct Node { //定义连接链表的节点： Node* next; }node; typedef struct Common_list { //定义一个空间域 node head; int length; }common_
C语言数据结构之循环链表的简单实例
12-26
C语言数据结构之循环链表的简单实例 实例代码： # include # include typedef struct node //定义链表中结点的结构 { int code; struct node *next; }NODE,*LinkList; /*错误信息输出函数*/ void Error(char *...
通过C语言实现数据结构的循环链表
12-26
循环链表的节点结构通常包含两部分：数据域和指针域。数据域用于存储节点的数据，指针域用于指向下一个节点。 在循环链表中，通常会有一个头指针指向第一个节点。通过头指针可以遍历整个循环链表。添加一个新节点时...
数据结构-循环链表-C语言实现循环链表功能-数据结构学习
最新发布
05-26
C语言实现的数据结构中的循环链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对循环链表边界的判定 实现了以下功能： 创建无头循环链表 向循环链表中插入...
C语言数据结构之双向循环链表的实例
08-30
C语言数据结构之双向循环链表的实例 在计算机科学中，链表是一种常用的数据结构，它可以动态地分配内存来存储数据，且可以随机访问和插入、删除数据。双向循环链表是一种特殊的链表，它可以同时在链表的头部和尾部...
C语言 数据结构双向链表简单实例
08-31
C语言数据结构双向链表简单实例 本文主要介绍了C语言数据结构双向链表简单实例的相关知识点，包括双向链表的基本操作、删除元素、插入元素、判断对称性、排序等。 一、双向链表的基本操作 双向链表是一种数据结构...
c语言简单循环链表
04-22
#include <stdio.h> #include <stdlib.h> int main(void) { //线性表在计算机中的存储结构是连续的 //以下是两种建立线性表的方式,可能还有更多方法 int lineTable[10]; int *ptrlineTable = (int *) malloc (sizeof(int)); free(ptrlineTable); return 0; }
循环链表C语言实现
02-03
代码包含以下功能，经过产品验证，代码运行可靠。 1.创建链表 2.销毁链表 3.获取链表长度 4.清空链表 5.获取第pos个元素操作 6.插入元素到位置pos 7.删除位置pos处的元素 8.获取当前游标指向的数据元素； 9.将游标重置指向链表中的第一个数据元素； 10.将游标移动指向到链表中的下一个数据元素； 11.直接指定删除链表中的某个数据元素。
数据结构_循环链表(C语言)
小黯
07-17 786
循环链表 1.结构解析 循环链表是另一种形式的链式存贮结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。 图示： 2.源代码: #include<stdio.h> #include<stdlib.h> typedef char ElemType; typedef struct CNode { ElemType data; struct CNode *next; }CNode, *CLinkList; void InitList(CLinkList
数据结构之循环链表（C语言）
sskdspdl的博客
09-03 719
用C语言实现循环链表
C语言实现循环链表
Luminescent_fish的博客
01-26 765
数据结构学习笔记|循环链表的创建、初始化、判空与表尾结点判断的代码实现
用C语言实现循环链表
皓阳当空-博客
05-22 624
将单项链表的尾节点指针指向此链表的头结点，即组成了循环链表。 具体实现代码如下【C语言，在vs开发工具下调试通过】 源码分三个文件，分别为CircleLinkList.h CircleLinkList.c main.c CircleLinkList.h源码： #ifndef CIRCLELINKLIST #define CIRCLELINKLIST #include #include
《数据结构》（C语言版）——循环链表
prlhnxx的博客
02-09 380
/* run this program using the console pauser or add your own getch, system("pause") or input loop */ // 用到的库文件 #include &lt;stdio.h&gt; // printf();scanf() #include &lt;stdlib.h&gt; // exit() #includ...
c语言实现循环链表
m0_51835877的博客
10-27 891
循环链表的创建其实并不复杂，只需要在创建单链表时定义一个节点（本文章中为s）参与循环找到尾节点然后让其指向头节点的下一个（因为第一个节点时没有值的），在之后的遍历中则需要使用do while循环因为跳跃了第一个节点在我们遍历时新的第一个节点是有值的，之后的插入删除查找操作，则是在原文的基础上删除了循环中超越元素值的条件，举例：现有四个元素：1 2 3 4，删除第7个元素后：1 2 4. #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #incl
c语言 实现循环链表
jiangjun_feng的博客
05-01 598
原文地址 挺厉害的，没有错误 #include <stdio.h> #include <stdlib.h> #define TRUE 1 #define FALSE 0 typedef int Status; // Status是函数结果状态，成功返回TRUE,失败返回FALSE typedef int ElemType; /* 线性表的循环链表存储结构 */ typedef struct node { ElemType data; struct node *next; }
C语言数据结构双向循环链表
09-27
在C语言中，实现双向循环链表需要定义一个链表节点结构体，其中包含指向前驱节点和后继节点的指针，以及存储数据的成员。以下是一个示例的C语言代码来初始化一个双向循环链表： ``` typedef int LTDataType; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值