循环单链表的代码实现

已于 2024-04-03 13:31:03 修改
阅读量111 收藏
点赞数
分类专栏： 数据结构设计与应用 文章标签： 链表 数据结构 c语言 java
于 2023-08-05 10:08:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55094971/article/details/128470741
版权

        循环链表（Circular Linked List）是另一种形式的链式存储结构。其特点是表中最后一个节点的指针域指向头节点，整个链表形成一个环。由此，从表中任意节点出发均可以找到表中其他节点，下图所示为单链的循环链表。类似地，还可以有多重链的循环链表。

                                                               680ec67da21f28b39fa9e007e624b7de.png

        循环单链表的操作和单链表基本一致，差别仅在于：当链表遍历时，判断当前指针p是否指向表尾结点的终止条件不同。在单链表中，判断条件为p!=NULL或p->next!=NULL，而循环单链表的判别条件为p!=L或p->next!=NULL。

        以下就是循环单链表的不同代码实现:

        C语言代码(CircularSingleLinkedList)

#ifndef CIRCULARSINGLELINKEDLIST_H_INCLUDED
#define CIRCULARSINGLELINKEDLIST_H_INCLUDED
typedef int ElemType; //It is changeble to change this data type.
typedef struct Node
{
    ElemType elem;
    struct Node *next;
}*LinkedList,LNode;
void InitList(LinkedList *L)
{
    (*L)=(LNode*)malloc(sizeof(LNode));
    (*L)->next=(*L);
}
void DestroyList(LinkedList *L)
{
    LNode *p=(*L);
    while((*L)->next!=(*L))
    {
        p=(*L)->next;
        (*L)->next=p->next;
        free(p);
        p=NULL;
    }
    (*L)=NULL;
}
void ClearList(LinkedList *L)
{
    LNode *p=(*L);
    while((*L)->next!=(*L))
    {
        p=(*L)->next;
        (*L)->next=p->next;
        free(p);
    }
}
int ListEmpty(LinkedList *L)
{
    LNode *p=(*L);
    if(p->next!=(*L))
    {
        return 0;
    }
    else
    {
        return 1;
    }
}
int ListLength(LinkedList *L)
{
    int i=0;
    LNode *p=(*L);
    while(p->next!=(*L))
    {
        p=p->next;
        i++;
    }
    return i;
}
ElemType GetElem(LinkedList *L,int index)
{
    if(index<0||index>=ListLength(L))
    {
        return -1;
    }
    LNode *p=(*L)->next;
    int i=0;
    while(i<index)
    {
        i++;
        p=p->next;
    }
    return p->elem;
}
int LocateElem(LinkedList *L,ElemType elem)
{
    LNode *p=(*L)->next;
    int i=0;
    while(i<ListLength(L))
    {
        if(p->elem==elem)
        {
            return i;
        }
        p=p->next;
        i++;
    }
    return -1;
}
ElemType PriorElem(LinkedList *L,ElemType elem)
{
    LNode *p=(*L)->next;
    while(p!=(*L))
    {
        if(p->next->elem==elem)
        {
            return p->elem;
        }
        else if(LocateElem(L,elem)==0)
        {
            while(p->next!=(*L))
            {
                p=p->next;
            }
            return p->elem;
        }
        p=p->next;
    }
    return -1;
}
ElemType NextElem(LinkedList *L,ElemType elem)
{
    LNode *p=(*L)->next;
    while(p!=(*L))
    {
        if(p->elem==elem)
        {
            if(ListLength(L)==(LocateElem(L,elem)+1))
            {
                return p->next->next->elem;
            }
            else
            {
                return p->next->elem;
            }
        }
        p=p->next;
    }
    return -1;
}
void addFirst(LinkedList *L,ElemType elem)
{
    LNode *s;
    s=(LNode*)malloc(sizeof(LNode));
    s->elem=elem;
    s->next=(*L)->next;
    (*L)->next=s;
}
void addAfter(LinkedList *L,ElemType elem)
{
    LNode *s,*p=(*L);
    s=(LNode*)malloc(sizeof(LNode));
    s->elem=elem;
    while(p->next!=(*L))
    {
        p=p->next;
    }
    s->next=p->next;
    p->next=s;
}
int ListInsert(LinkedList *L,int index,ElemType elem)
{
    if(index<0||index>ListLength(L))
    {
        return -1;
    }
    LNode *p=(*L),*s;
    s=(LNode*)malloc(sizeof(LNode));
    s->elem=elem;
    int i=0;
    while(i<index)
    {
        p=p->next;
        i++;
    }
    s->next=p->next;
    p->next=s;
    return 1;
}
int ListDelete(LinkedList *L,int index)
{
    if(index<0||index>=ListLength(L))
    {
        return -1;
    }
    LNode *p=(*L),*del;
    int i=0;
    while(i<index)
    {
        p=p->next;
        i++;
    }
    del=p->next;
    p->next=del->next;
    free(del);
    return 1;
}
void TraverseList(LinkedList *L)
{
    LNode *p=(*L)->next;
    while(p!=(*L))
    {
        printf("%d\t",p->elem);
        p=p->next;
    }
    printf("\n");
}
#endif // CIRCULARSINGLELINKEDLIST_H_INCLUDED

        C语言测试用例代码：

#include <stdio.h>
#include <stdlib.h>
#include <C:\Users\12952\Desktop\testc\CircularSingleLinkedList.h>
int main()
{
    LinkedList list;
    while(1)
    {
        printf("1:初始化顺序表  2:销毁顺序表  3:清理顺序表  4:判断表空\n5:返回表长  6:利用下标获取元素值  7:返回元素的位置  8:返回前驱元素\n9:返回后继元素  10:插入顺序表  11:删除表元素  12:遍历线性表\n13:前插元素 14:后插元素\n请选择操作选项:\n");
        int op;
        scanf("%d",&op);
        switch(op)
        {
        case 1:
            {
                InitList(&list);
                break;
            }
        case 2:
            {
                DestroyList(&list);
                break;
            }
        case 3:
            {
                ClearList(&list);
                break;
            }
        case 4:
            {
                if(ListEmpty(&list)==1)
                {
                    printf("表为空\n");
                }
                else
                {
                    printf("表不为空\n");
                }
                break;
            }
        case 5:
            {
                printf("表长为:%d\n",ListLength(&list));
                break;
            }
        case 6:
            {
                printf("请输入下标值:");
                int get;
                scanf("%d",&get);
                if(GetElem(&list,get)!=-1)
                {
                    printf("下标值%d对应的元素值为:%d\n",get,GetElem(&list,get));
                }
                else
                {
                    printf("无此元素\n");
                }
                break;
            }
        case 7:
            {
                printf("请输入元素值:");
                int get;
                scanf("%d",&get);
                if(LocateElem(&list,get)!=-1)
                {
                    printf("元素%d对应的下标值为:%d\n",get,LocateElem(&list,get));
                }
                else
                {
                    printf("无此元素\n");
                }
                break;
            }
        case 8:
            {
                printf("请输入元素值:");
                int get;
                scanf("%d",&get);
                if(PriorElem(&list,get)!=-1)
                {
                    printf("元素%d对应的前驱元素为:%d\n",get,PriorElem(&list,get));
                }
                else
                {
                    printf("无此元素\n");
                }
                break;
            }
        case 9:
            {
                printf("请输入元素值:");
                int get;
                scanf("%d",&get);
                if(NextElem(&list,get)!=-1)
                {
                    printf("元素%d对应的后继元素为:%d\n",get,NextElem(&list,get));
                }
                else
                {
                    printf("无此元素\n");
                }
                break;
            }
        case 10:
            {
                printf("请输入元素值:");
                int get;
                scanf("%d",&get);
                printf("请输入元素的位置:");
                int get1;
                scanf("%d",&get1);
                if(ListInsert(&list,get1,get)==1)
                {
                    printf("元素插入成功.\n");
                    TraverseList(&list);
                }
                else
                {
                    printf("插入失败\n");
                }
                break;
            }
        case 11:
            {
                printf("请输入下标值:");
                int get;
                scanf("%d",&get);
                if(ListDelete(&list,get)==1)
                {
                    printf("已删除元素\n");
                    TraverseList(&list);
                }
                else
                {
                    printf("未找到此元素\n");
                }
                break;
            }
        case 12:
            {
                printf("表中元素如下:\n");
                TraverseList(&list);
                break;
            }
        case 13:
            {
                printf("请输入元素的值:");
                int get;
                scanf("%d",&get);
                addFirst(&list,get);
                TraverseList(&list);
                break;
            }
        case 14:
            {
                printf("请输入元素的值:");
                int get;
                scanf("%d",&get);
                addAfter(&list,get);
                TraverseList(&list);
                break;
            }
        }
    }
    return 0;
}

        Java代码:

//该文件对应的包路径为:DataStructure.LinearList.LinkedList
package DataStructure.LinearList;
public class LinkedList
{
    protected Object elem;
    protected LinkedList next;
    public LinkedList(Object elem)
    {
        this.elem=elem;
    }
    public LinkedList(){}
}

//该文件对应的包路径为:DataStructure.LinearList.CircularSingleLinkedList.java
package DataStructure.LinearList;
public class CircularSingleLinkedList{
    private LinkedList list;
    private LinkedList head;
    public void InitList()
    {
        list=new LinkedList();
        this.head=list;
        head.next=head;
    }
    public Boolean DestoryList()
    {
        try
        {
            ClearList();
            head=null;
            return true;
        }
        catch (NullPointerException e)
        {
            System.out.println("This SingleLinkedList has been destoried");
            return true;
        }
    }
    public Boolean ClearList()
    {
        LinkedList temp=head;
        while (temp.next!=head)
        {
            temp=temp.next;
        }
        temp.next=null;
        head.next=head;
        return true;
    }
    public Boolean ListEmpty()
    {
        if(head.next==head)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    public int ListLength()
    {
        LinkedList temp=head;
        int i=0;
        while (true)
        {
            if(temp.next==head)
            {
                break;
            }
            else
            {
                i++;
                temp=temp.next;
            }
        }
        return i;
    }
    public Object GetElem(int index)
    {
        if(index<0||index>=this.ListLength())
        {
            return -1;
        }
        else
        {
            LinkedList temp=head;
            int i=0;
            while(i<index)
            {
                temp=temp.next;
                i++;
            }
            return temp.elem;
        }
    }
    public int LocateElem(Object elem)
    {
        LinkedList temp=head;
        for (int i = 0; i < this.ListLength(); i++)
        {
            if(temp.elem.equals(elem))
            {
                return i;
            }
            else
            {
                temp=temp.next;
            }
        }
        return -1;
    }
    public Object PriorElem(Object elem)
    {
        LinkedList temp=head;
        for(int i=0;i<this.ListLength()-1;i++)
        {
            if(temp.next.elem.equals(elem))
            {
                return temp.elem;
            }
            else if (this.LocateElem(elem)==0)
            {
               while (temp.next.next!=head)
                {
                    temp=temp.next;
                }
                return temp.elem;
            }
            else
            {
                temp=temp.next;
            }
        }
        return -1;
    }
    public Object NextElem(Object elem)
    {
        LinkedList temp=head;
        for (int i = 0; i < this.ListLength(); i++)
        {
            if(temp.elem.equals(elem))
            {
                if (this.LocateElem(elem)==this.ListLength()-1)
                {
                    return temp.next.next.elem;
                }
                else
                {
                    return temp.next.elem;
                }
            }
            else
            {
                temp=temp.next;
            }
        }
        return -1;
    }
    public Boolean ListInsert(Object elem,int index)
    {
        if(index<0||index>this.ListLength())
        {
            return false;
        }
        LinkedList temp=head;
        if (index==0)
        {
            addFirst(elem);
            return true;
        }
        if(index>0)
        {
            for (int i = 1; i < index; i++)
            {
                temp=temp.next;
            }
            LinkedList node=new LinkedList(elem);
            node.next=temp.next;
            temp.next=node;
        }
        return true;
    }
    public void addFirst(Object elem)
    {
        LinkedList node=new LinkedList(elem);
        LinkedList temp=head;
        while (temp.next!=head)
        {
            temp=temp.next;
        }
        temp.next=node;
        node.next=head;
        head=node;
    }
    public void addAfter(Object elem)
    {
        LinkedList temp=head;
        int i=0;
        if(this.ListLength()==0)
        {
            addFirst(elem);
        }
        else
        {
            while (i<this.ListLength()-1)
            {
                temp=temp.next;
                i++;
            }
            LinkedList node=new LinkedList(elem);
            node.next=temp.next;
            temp.next=node;
        }
    }
    public Boolean DeleteElem(int index)
    {
        if(index<0||index>this.ListLength()-1)
        {
            return false;
        }
        LinkedList temp=head;
        if(index==0)
        {
            LinkedList save=temp.next;
            while (temp.next!=head)
            {
                temp=temp.next;
            }
            temp.next=save;
            head=save;
            return true;
        }
        else
        {
            for (int i = 0; i < index-1; i++) {
                temp=temp.next;
            }
            LinkedList delete=temp.next;
            temp.next=delete.next;
            delete.next=null;
            return true;
        }
    }
    public void TraverseList()
    {
        LinkedList temp=head;
        while(true) 
        {
            if(temp.next==head)
            {
                break;
            }
            else
            {
                System.out.print(temp.elem+"\t");
                temp=temp.next;
            }
        }
        System.out.println("");
    }
}

        Java语言测试用例：

import DataStructure.LinearList.CircularSingleLinkedList;
import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        CircularSingleLinkedList list=new CircularSingleLinkedList();
        Scanner sc=new Scanner(System.in);
        int op;
        while (true)
        {
            System.out.println("1:初始化线性表;2:销毁线性表;3:清理线性表;4:判断表空;5:返回表长;6:按下标值获取元素;7:返回元素所在位置;" +
                    "8:返回前驱元素;9:返回后继元素;10:插入线性表;11:前插元素;12:后插元素;13:按下标值删除元素;14:遍历线性表");
            System.out.println("请输入操作选项：");
            op=sc.nextInt();
            switch (op)
            {
                case 1:
                {
                    list.InitList();
                    System.out.println("初始化完成");
                    break;
                }
                case 2:
                {
                    list.DestoryList();
                    System.out.println("销毁完成");
                    break;
                }
                case 3:
                {
                    list.ClearList();
                    System.out.println("清理完成");
                    break;
                }
                case 4:
                {
                    if(list.ListEmpty())
                    {
                        System.out.println("表为空");
                    }
                    else
                    {
                        System.out.println("表不为空");
                    }
                    break;
                }
                case 5:
                {
                    System.out.printf("表长为:%d\n",list.ListLength());
                    break;
                }
                case 6:
                {
                    System.out.print("请输入下标值:");
                    int getch=sc.nextInt();
                    System.out.println("下标"+getch+"对应的元素值为:"+list.GetElem(getch));
                    break;
                }
                case 7:
                {
                    System.out.print("请输入元素值:");
                    Object getch=sc.nextInt();
                    System.out.println("元素"+getch+"对应的下标为:"+list.LocateElem(getch));
                    break;
                }
                case 8:
                {
                    System.out.print("请输入元素值:");
                    Object getch=sc.nextInt();
                    if((int)list.PriorElem(getch)!=-1)
                    {
                        System.out.println("元素"+getch+"对应的前驱元素为:"+list.PriorElem(getch));
                    }
                    else
                    {
                        System.out.println("无此元素");
                    }
                    break;
                }
                case 9:
                {
                    System.out.print("请输入元素值:");
                    Object getch=sc.nextInt();
                    if((int)list.NextElem(getch)!=-1)
                    {
                        System.out.println("元素"+getch+"对应的后继元素为:"+list.NextElem(getch));
                    }
                    else
                    {
                        System.out.println("无此元素");
                    }
                    break;
                }
                case 10:
                {
                    System.out.print("请输入要插入的元素:");
                    int getch=sc.nextInt();
                    System.out.print("请输入插入的位置:");
                    int getch1= sc.nextInt();
                    if (list.ListInsert(getch,getch1))
                    {
                        System.out.println("插入成功");
                        list.TraverseList();
                    }
                    else
                    {
                        System.out.println("插入失败");
                        list.TraverseList();
                    }
                    break;
                }
                case 11:
                {
                    System.out.print("请输入要插入的元素值:");
                    Object getch=sc.nextInt();
                    list.addFirst(getch);
                    list.TraverseList();
                    break;
                }
                case 12:
                {
                    System.out.print("请输入要插入的元素值:");
                    Object getch=sc.nextInt();
                    list.addAfter(getch);
                    list.TraverseList();
                    break;
                }
                case 13:
                {
                    System.out.print("请输入下标值:");
                    int getch=sc.nextInt();
                    list.DeleteElem(getch);
                    list.TraverseList();
                    break;
                }
                case 14:
                {
                    System.out.println("元素如下:");
                    list.TraverseList();
                    break;
                }
            }
        }
    }
}

 

 

 

 

 

 

荧光百叶草
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
循环单链表的简单实现（C语言）
文溪山人的博客
03-21 3831
循环单链表的简单实现（C语言）
单向循环链表实现
hxy1625309592的博客
12-15 1477
1.1 基本介绍 循环链表，顾名思义，链表整体要形成一个圆环状。在单向链表中，最后一个节点的指针为null，不指向任何结点，因为没有下一个元素了。要实现循环链表，只需要让单向链表的最后一个节点的指针指向头结点即可。 1.2 添加操作 1、思路分析 链表为空的时候 让head和tail同时指向这个结点，让尾结点的下一跳指向头结点。 头部添加 先让要添加的元素指向head,然后再将head指针指向新结点。 最后让tail指针下一跳重新指向头结点 尾部添加 直接让新结点的下一跳指
循环单链表的实现代码
2401_82757880的博客
05-09 234
【代码】双向链表的实现代码。
线性表文档之循环单链表
二木成林
04-05 1702
线性表文档之循环单链表
用循环单链表实现队列
qq_42824207的博客
12-04 2929
假设以带头结点的单循环链表实现链式队列，并且要求只设尾指针，不设头指针，编写实现这种链式队列初始化、入队列和出队列操作的函数 入队：我们只需要在尾节点后插入元素即可，需要注意的是，不可以使用尾插法，因为是循环链表,rear->next是头指针，所以我们应该在尾节点使用头插法，并让rear指向新队尾。出队：需要注意当出队后，队列为空时，rear指向头结点 在不带头结点的循环链表中，(rear->next == rear) 表示该队列中只有一个元素； 在带头结点的循环链表中，(rear-...
cpp代码-循环单链表CRUD
07-14
在计算机科学领域，循环单链表是一种常见的数据结构，它在C++编程中被广泛用于实现各种算法和数据管理任务。循环单链表与普通单链表的主要区别在于最后一个节点的指针不是空的，而是指向了链表的第一个节点，形成一...
数据结构 C语言实现循环单链表的实例
08-30
数据结构 C语言实现循环单链表的实例 数据结构是计算机科学中的一门重要学科，它研究的是数据的存储、表示和操作的方法。在计算机科学中，数据结构是指数据的组织、存储和操作的方法。循环单链表是一种常见的数据...
基于java的循环单链表
12-22
循环单链表是一种常见的数据结构，它在计算机科学和编程中有着广泛的应用。与普通单链表不同，循环单链表的最后一个元素...理解并掌握循环单链表的原理和实现，对于学习数据结构和算法以及编写高效的Java代码至关重要。
数据结构day3
qq_55245263的博客
07-18 260
顺序表实现学生管理系统
数组算法--基本查找
最新发布
2303_78660417的博客
07-20 295
基本查找就是从数组的0索引处开始，依次往后查找，如果找到了对应索引处的值，就会，如果没有找到。因为数组的索引号是没有-1的，当返回-1的时候，就能明白没有找到。
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1034
可以参考以下视频。
数据结构初阶·排序算法(内排序)
2301_79697943的博客
07-18 847
目前常见的排序算法有9种，冒泡排序，选择排序，插入排序，希尔排序，快速排序，归并排序，计数排序，基数排序，桶排序。实际生活中排序的应用也是有限的，今天我们介绍其中7个，基数排序和桶排序不介绍。介绍常用的即可。顺带一嘴，本文里面所有的排序都是内排序，也就是在内存里面进行排序的，还有一种排序叫做外排序，即是在磁盘里面进行排序的，这种排序具有记忆性，外排序用到的就是归并排序，因为归并排序有一个特点就是空间复杂度为O(N)。好了正文开始。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 225
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
数据结构第32节 无锁编程
hummhumm的专栏
07-17 851
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
数据结构——栈
weixin_45942515的博客
07-19 248
1、栈的英文为stack2、栈是先入后出（FILO-First In Last Out）的有序列表。3、栈stack是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶 (Top)，另一端固定的一端，称为栈底(Bottom)。4、根据栈的定义可知，最先放入栈中的元素在栈底，最后放入栈中的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
数据结构之细说链表
m0_73634434的博客
07-17 1063
这里while循环的条件判断必须是tail->next->next，因为我们需要释放最后一个节点的地址，所以需要利用它前面一共节点来释放它，然后将tail->next置空，如果我们直接找最后一个地址然后将它释放前面一个节点就会指向被释放的地址变成一个野指针，因为我们已经找不到前面一个节点的位置了。头插就比较简单了，将该节点连接在第一个节点和第二个节点之间就可以了，但是我们需要先连接第二个和新节点，如果先连接第一个节点和新节点就会找不到第二个节点的地址。下面我们给出链表的构成，看看链表是如何解决这些问题的。
24暑假算法刷题 | Day16 | LeetCode 513. 找树左下角的值，112. 路径总合，106. 从中序和后序遍历序列构造二叉树
weixin_54468359的博客
07-18 1084
24暑假刷题day15打卡 二叉树进阶
数据结构 day2
没有百宝袋的哆啦A梦的博客
07-17 1166
由相同数据类型或不同数据类型构成的集合，但是，该集合中的成员共享同一块内存空间union 结构体名称成员类型1 成员变量1;成员类型2 成员变量2；。。。成员类型n 成员变量n;当程序员写程序时，可能会因为数据类型的问题，在定义变量时，导致该程序比较晦涩难懂，例如：unsigned long int ,struct Stu为了提高代码的简洁性，以及为了更加方便理解使得代码更加优雅，我们可以将这些类型重新起一个简洁好记的名字。引入了关键字 typedef。
创建空数据结构：列表、元组、字典和集合
2202_75569688的博客
07-17 178
在 Python 编程中，数据结构是存储和管理数据的基本单元。常用的数据结构包括列表、元组、字典和集合。在实际编程中，时常需要初始化这些数据结构为空。本文将详细介绍如何创建空列表、空元组、空字典和空集合。
循环单链表c语言实现基本操作
10-08
循环单链表是一种链表的实现方式，它的特点是在单链表的基础上，将尾节点指向头节点，形成一个循环。循环单链表的基本操作包括插入、删除、查找等。...完整的循环单链表C语言实现代码可以参考引用中提供的资源链接。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

荧光百叶草

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值