广义表链表表示的复制删除比较运算的非递归实现(c++)

已于 2024-08-16 01:50:24 修改
阅读量396 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 c++ 数据结构
于 2021-12-06 21:17:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/naturerun/article/details/121756402
版权

广义表链表表示的删除：

从广义表附加头节点开始，逐一分离表头元素，是原子项就直接删除,是子表附加头节点则暂不删除，直接进入子表，再分离表头元素，然后用相同的方法删除，子表删除完成后向上回溯，继续删除上一层子表，如此不断进行直到整个广义表被删除为止

代码（C++）

#include <iostream>
#include <vector>
#include<string>
using namespace std;

struct Gen
{
    int utype;
    union
    {
        int ref;
        struct Gen* hlink;
        char value;
    }info;
    struct Gen* tlink;
    Gen(int u);
    Gen(int u, char v);
};
Gen::Gen(int u) :utype(u), tlink(nullptr)
{
    if (u == 0)
        info.ref = 0;
    else
        info.hlink = nullptr;
}

Gen::Gen(int u, char v) :utype(u), tlink(nullptr)
{
    info.value = v;
}

Gen* strtogen();

int main()
{
    Gen* ptr = strtogen(); //ptr初始化为广义表附加头结点指针
    bool TF = true;
    vector<Gen*> stack;

    while (true)
    {
        if (ptr != nullptr && (ptr->utype == 0 || ptr->utype == 1))
        {
            if (TF == true)
            {
                stack.push_back(ptr);
                if (ptr->utype == 0)
                {
                    if (ptr->tlink == nullptr)
                    {
                        stack.pop_back();
                        TF = false;
                        continue;
                    }
                    ptr = ptr->tlink;   //拉链，分理出广义表附加头节点的下一待删除节点
                    stack.back()->tlink = ptr->tlink;
                }
                else
                {
                    if (ptr->info.hlink == nullptr)
                        TF = false;
                    else
                    {
                        ptr = ptr->info.hlink;   //拉链，分离出ptr指向的子表附加头节点在子表中的下一节点
                        stack.back()->info.hlink = ptr->tlink;
                    }
                }
            }
            else
            {
                if (ptr->utype == 0)
                {
                    delete ptr;
                    break;//删除附加头节点，至此删除成功，退出
                }
                else
                {   delete ptr;
                    stack.pop_back();    //删除子表附加头节点，子表删除成功
                    ptr = nullptr;
                }
            }
        }
        else
        {
            if (ptr != nullptr)
            {
                delete ptr;
            }

            if (stack.back()->utype == 0 && stack.back()->tlink == nullptr || stack.back()->utype != 0 && stack.back()->info.hlink == nullptr)
            {
                TF = false;
                ptr = stack.back();
                if (stack.back()->utype == 0)
                {
                    stack.pop_back();
                }
            }
            else
            {
                if (ptr == nullptr)
                    TF = true;

                if (stack.back()->utype == 0)
                {
                    ptr = stack.back()->tlink;
                    stack.back()->tlink = ptr->tlink;
                }
                else
                {
                    ptr = stack.back()->info.hlink;
                    stack.back()->info.hlink = ptr->tlink;
                }
            }
        }
    }
    //运行结束后ptr成为野指针,栈空,删除成功
    cout << "链表形式的广义表删除成功!" << endl;
    return 0;
}

Gen* strtogen()
{
    string glist;
    cout << "请输入广义表的字符串形式" << endl;
    cin >> glist;

    Gen* ptr = nullptr; vector<Gen*> stack; bool TF;
    auto i = glist.cbegin();
    ++i;
    ptr = new Gen(0);
    stack.push_back(ptr);
    TF = true;

    for (; i != glist.cend(); ++i)
    {
        Gen* temp;
        if (*i == '(')
        {
            temp = new Gen(1);
        }
        else
        {
            if (*i == ')')
            {
                ptr = stack[stack.size() - 1];
                stack.pop_back();
                TF = false;
                continue;
            }

            if (*i != ',')
            {
                temp = new Gen(2, *i);
            }
            else
                continue;
        }

        if (ptr->utype == 1)
        {
            if (TF == true)
                ptr->info.hlink = temp;
            else
                ptr->tlink = temp;
        }
        else
        {
            ptr->tlink = temp;
        }

        if (*i == '(')
        {

            stack.push_back(temp);
            TF = true;
        }
        ptr = temp;
    }
    cout << "已将字符串形式的广义表转换为链表形式" << endl;
    return ptr;
}

广义表链表表示的复制：

就是按广度优先遍历的次序逐一复制，为方便复制，目标表指针总比原表遍历指针慢一步，原表遍历完成后复制就结束了

#include <iostream>
#include <vector>
#include <string>
using namespace std;

struct Gen
{
    int utype;
    union
    {
        int ref;
        struct Gen* hlink;
        char value;
    }info;
    struct Gen* tlink;
    Gen(int u);
    Gen(int u, char v);
};
Gen::Gen(int u) :utype(u), tlink(nullptr)
{
    if (u == 0)
        info.ref = 0;
    else
        info.hlink = nullptr;
}

Gen::Gen(int u, char v) :utype(u), tlink(nullptr)
{
    info.value = v;
}

Gen* strtogen();
void suboutput(Gen* head);

int main()
{
    vector<Gen*> stack1;//源栈 
    vector<Gen*> stack2;//目标栈
    Gen* ptr1 = strtogen(); //ptr1初始化为源广义表附加头节点指针
    Gen* ptr2 = nullptr; //ptr2为目标广义表拷贝指针
    bool TF = true;

    while (true)  //循环开始,将源广义表链表表示拷贝为目标广义表链表表示
    {
        bool t = (ptr1 != nullptr) && (ptr1->utype == 0 || ptr1->utype == 1);
        if (t || ptr1 != nullptr)
        {
            if (t == false || TF && ptr1->utype != 0 && ptr2->utype == 1)
            {
                if (t)
                {
                    stack1.push_back(ptr1);
                }

                Gen* temp;
                if (t)
                {
                    temp = new Gen(1);
                }
                else
                {
                    temp = new Gen(2, ptr1->info.value);
                }

                if ((t || ptr2->utype == 1) && ptr2 == stack2.back())
                {                                  //ptr2新进至子表头节点,源广义表子表头节点链接至ptr2所指子表中头节点后
                    ptr2->info.hlink = temp;
                }
                else
                {
                    ptr2->tlink = temp;
                }

                ptr2 = temp;
                if (t)
                {
                    stack2.push_back(ptr2);
                    ptr1 = ptr1->info.hlink;
                }
                else
                {
                    ptr1 = ptr1->tlink;
                }
            }
            else
            {
                if (TF == false)
                {
                    ptr2 = stack2.back();
                    stack2.pop_back();
                    if (ptr1->utype == 0)
                    {
                        break; //拷贝完毕，退出，ptr2为目标广义表头节点
                    }
                    else
                    {
                        ptr1 = ptr1->tlink;
                        TF = true;
                    }
                }
                else
                {
                    stack1.push_back(ptr1);
                    if (ptr1->utype == 0)
                    {
                        ptr2 = new Gen(0);           //拷贝广义表附加头节点,完成后ptr1递进
                        ptr2->info.ref = ptr1->info.ref;
                        ptr1 = ptr1->tlink;
                    }
                    else
                    {
                        Gen* temp = new Gen(1); //由于ptr2指向目标广义表头节点或原子项，所以直接把待拷贝子表头节点链接于其后
                        ptr2->tlink = temp;
                        ptr2 = temp;
                        ptr1 = ptr1->info.hlink;
                    }
                    stack2.push_back(ptr2);
                }
            }
        }
        else
        {
            ptr2 = nullptr;
            ptr1 = stack1.back();
            stack1.pop_back();
            TF = false;
        }
    }

    /*while (true)
    {
        if (ptr1 != nullptr && (ptr1->utype == 0 || ptr1->utype == 1))
        {
            if (TF == true)
            {
                stack1.push_back(ptr1);
                if (ptr1->utype == 0)
                {
                    ptr2 = new Gen(0);           //拷贝广义表附加头节点,完成后ptr1递进
                    ptr2->info.ref = ptr1->info.ref;
                    ptr1 = ptr1->tlink;
                }
                else
                {
                    Gen* temp = new Gen(1);
                    if (ptr2->utype == 1)  //需要把子表附加头节点拷贝至ptr2所指附加头节点后
                    {
                        if (ptr2 == stack2.back())   //ptr2新进至子表头节点,源广义表子表头节点链接至ptr2所指子表中头节点后
                            ptr2->info.hlink = temp;
                        else
                            ptr2->tlink = temp;
                    }
                    else
                    {
                         ptr2->tlink = temp;  //由于ptr2指向目标广义表头节点或原子项，所以直接把待拷贝子表头节点链接于其后
                    }
                    ptr2 = temp;
                    ptr1 = ptr1->info.hlink;
                }
                stack2.push_back(ptr2);
            }
            else
            {
                ptr2 = stack2.back();
                stack2.pop_back();
                if (ptr1->utype == 0)
                {
                    break; //拷贝完毕，退出，ptr2为目标广义表头节点
                }
                else
                {
                    ptr1 = ptr1->tlink;
                    TF = true;
                }
            }
        }
        else
        {
            if (ptr1 == nullptr)  //子表拷贝完毕
            {
                ptr2 = nullptr;
                ptr1 = stack1.back();
                stack1.pop_back();
                TF = false;
            }
            else
            {
                Gen* temp = new Gen(2, ptr1->info.value);  //拷贝原子项
                if (ptr2->utype == 1 && stack2[stack2.size() - 1] == ptr2)
                    ptr2->info.hlink = temp;   //如果ptr2新进至子表头节点，操作和上述相同
                else
                    ptr2->tlink = temp;   //操作和上述相同
                ptr2 = temp;
                ptr1 = ptr1->tlink;
            }
        }
    }*/
    cout << "复制完成,复制后的广义表为:";
    suboutput(ptr2);   //输出复制后的广义表
    return 0;
}

Gen* strtogen()
{

    string glist;
    cout << "请输入广义表的字符串形式" << endl;
    cin >> glist;

    Gen* ptr = nullptr; vector<Gen*> stack; bool TF;
    auto i = glist.cbegin();
    ++i;
    ptr = new Gen(0);
    stack.push_back(ptr);
    TF = true;

    for (; i != glist.cend(); ++i)
    {
        Gen* temp;
        if (*i == '(')
        {
            temp = new Gen(1);
        }
        else
        {
            if (*i == ')')
            {
                ptr = stack[stack.size() - 1];
                stack.pop_back();
                TF = false;
                continue;
            }

            if (*i != ',')
            {
                temp = new Gen(2, *i);
            }
            else
                continue;
        }

        if (ptr->utype == 1)
        {
            if (TF == true)
                ptr->info.hlink = temp;
            else
                ptr->tlink = temp;
        }
        else
        {
            ptr->tlink = temp;
        }

        if (*i == '(')
        {

            stack.push_back(temp);
            TF = true;
        }
        ptr = temp;
    }
    cout << "已将字符串形式的广义表转换为链表形式" << endl;
    return ptr;
}

void suboutput(Gen* head)
{
    Gen* ptr = head;
    bool TF = true;
    vector<Gen*> stack;
    while (true)
    {
        if (ptr != nullptr && (ptr->utype == 0 || ptr->utype == 1))  //注意
        {
            if (TF == true)
            {
                stack.push_back(ptr);
                cout << "(";
                if (ptr->utype == 0)   //注意
                {
                    ptr = ptr->tlink;
                }
                else
                {
                    ptr = ptr->info.hlink;
                }
            }
            else
            {
                if (ptr->utype == 0)
                    break;
                else
                {
                    ptr = ptr->tlink;
                    TF = true;
                }
            }
        }
        else
        {
            if (ptr == nullptr)
            {
                cout << ")";
                ptr = stack.back();
                if (ptr->utype != 0 && ptr->tlink != nullptr)    //注意
                    cout << ",";
                stack.pop_back();
                TF = false;
            }
            else
            {
                cout << ptr->info.value;
                ptr = ptr->tlink;
                if (ptr != nullptr)
                    cout << ",";
            }
        }
    }
    cout << endl;
}

基于广义表链表表示的比较：

两表指针同步动作，按广度优先遍历逐一比较，比较到某一处节点不等则广义表不等，否则会一直比较至遍历完整个广义表，此时两广义表相等

#include <iostream>
#include <vector>
#include <string>
using namespace std;

struct Gen
{
    int utype;
    union
    {
        int ref;
        struct Gen* hlink;
        char value;
    }info;
    struct Gen* tlink;
    Gen(int u);
    Gen(int u, char v);
};
Gen::Gen(int u) :utype(u), tlink(nullptr)
{
    if (u == 0)
        info.ref = 0;
    else
        info.hlink = nullptr;
}

Gen::Gen(int u, char v) :utype(u), tlink(nullptr)
{
    info.value = v;
}

bool equals(Gen* ptr1, Gen* ptr2); //判断ptr1和ptr2指向的广义表节点是否相等的函数
Gen* strtogen();

int main()
{
    vector<Gen*> stack1; vector<Gen*> stack2;
    Gen* ptr1 = strtogen(); //指向广义表1附加头节点
    Gen* ptr2 = strtogen(); //指向广义表2附加头节点
    //两指针同步动作
    bool TF = true;
    int isequals = 1; //=1两广义表相等，否则不等
    while (true)
    {
        if (ptr1 != nullptr && (ptr1->utype == 0 || ptr1->utype == 1))
        {
            if (TF == true)
            {
                if (ptr1->utype == 0 || equals(ptr1, ptr2))   //比较表1子表头节点或指针和表2对应位置节点或指针
                {
                    stack1.push_back(ptr1);
                    stack2.push_back(ptr2);
                    if (ptr1->utype != 0)     //附加头节点不必比较，跳过
                    {
                        ptr1 = ptr1->info.hlink;
                        ptr2 = ptr2->info.hlink;
                        continue;
                    }
                }
                else
                {
                    isequals = 0;  //不等,isequals置位，退出
                    break;
                }
            }
            else
            {
                if (ptr1->utype == 0)  //比较完成,退出
                    break;
                else
                {
                    TF = true;
                }
            }
        }
        else
        {
            if (equals(ptr1, ptr2))   
            {
                if (ptr1 == nullptr)
                {
                    ptr1 = stack1[stack1.size() - 1];    //比较ptr1或其指向节点和ptr2或其指向节点
                    ptr2 = stack2[stack2.size() - 1];
                    stack1.pop_back();
                    stack2.pop_back();
                    TF = false;
                    continue;
                }           //比较ptr1或其指向的原子项和表2对应位置指针ptr2或其指向的节点
            }
            else
            {
                isequals = 0;
                break;
            }
        }
        ptr1 = ptr1->tlink;  
        ptr2 = ptr2->tlink;
    }
    if (isequals)
        cout << "两广义表相等";
    else
        cout << "两广义表不等";
    cout << endl;
    return 0;
}

bool equals(Gen* ptr1, Gen* ptr2)   //ptr1和ptr2所指节点相等返回true否则返回false
{
    if (ptr1 == nullptr && ptr2 == nullptr)
        return true;
    else
    {
        if (ptr1 != nullptr && ptr2 != nullptr)
        {
            if (ptr1->utype != ptr2->utype)
                return false;
            else
            {
                if (ptr1->utype == 1)
                    return true;
                else
                {
                    if (ptr1->info.value == ptr2->info.value)
                        return true;
                    else
                        return false;
                }
            }
        }
        else
        {
            return false;
        }
    }
}

Gen* strtogen()
{

    string glist;
    cout << "请输入广义表的字符串形式" << endl;
    cin >> glist;

    Gen* ptr = nullptr; vector<Gen*> stack; bool TF;
    auto i = glist.cbegin();
    ++i;
    ptr = new Gen(0);
    stack.push_back(ptr);
    TF = true;

    for (; i != glist.cend(); ++i)
    {
        Gen* temp;
        if (*i == '(')
        {
            temp = new Gen(1);
        }
        else
        {
            if (*i == ')')
            {
                ptr = stack[stack.size() - 1];
                stack.pop_back();
                TF = false;
                continue;
            }

            if (*i != ',')
            {
                temp = new Gen(2, *i);
            }
            else
                continue;
        }

        if (ptr->utype == 1)
        {
            if (TF == true)
                ptr->info.hlink = temp;
            else
                ptr->tlink = temp;
        }
        else
        {
            ptr->tlink = temp;
        }

        if (*i == '(')
        {

            stack.push_back(temp);
            TF = true;
        }
        ptr = temp;
    }
    cout << "已将字符串形式的广义表转换为链表形式" << endl;
    return ptr;
}
naturerun
关注
专栏目录
广义表的复制
11-18
复制一个广义表的程序，主要是在自己定义了一个广义表以后，用程序的形式将它复制，没有递归
【实例】复制广义表
chaim16的博客
06-29 781
设广义表采用头链和尾链存储结构，编写把广义表la复制到另一个广义表的函数   广义表的存储结构分为： 头链和尾链存储结构 原子和子表存储结构   本文核心代码块：   注意：Glist为表的指针，GListNode,GLNode为实体 结构体如下： //复制广义表，l1复制给l2 void copyGList(GList *l2, GList l1) { if (!l1) *l2 = NULL; //复制空表 els
复制广义表
野狼
12-25 1034
根据广义表的信息和结构，将一个广义表复制到另外的一个广义表中 typedef enum{ ATOM,LIST; }ElemTag; //ATOM==0:原子，LIST==1:字表 typedef struct GLNODE{ ElemTag tag; //公共部分，用于区分原子节点和表结点 union{ AtomType atom; //at
广义表的拷贝 遍历 删除 置换（替换） 具体实现代码
牛大春の博客
10-24 394
直接上代码了… #include<iostream> #include<cstring> #include<math.h> #include<stdlib.h> using namespace std; enum GlistNodeType {ATOM,LIST }; template <class T > struct GlistNode { GlistNodeType type;//节点类型 union{ T data ;
广义表的头尾链表存储表示（第五章 P115 算法5.5,5.6,5.8）
但行好事，莫问前程
04-21 1798
/* 广义表的头尾链表存储表示 */ typedef enum{ATOM,LIST}ElemTag; /* ATOM==0:原子,LIST==1:子表 */ typedef struct GLNode { ElemTag tag; /* 公共部分,用于区分原子结点和表结点 */ union /* 原子结点和表结点的联合部分 */ { AtomTyp...
实现广义表的基本运算嘎嘎哈师大
最新发布
05-13
本次实验旨在通过编程实现广义表的基本运算，进一步理解广义表的链式存储结构及其基本算法设计。实验内容包括广义表的创建、求长度、求深度、输出以及销毁等操作。 #### 广义表简介 广义表是一种线性表的推广形式，...
解析C++的线性表链式存储设计与相关的API实现
09-02
本文将深入解析C++中的线性表链式存储设计及其相关的API实现。 链式存储的基本概念在于，每个数据元素（也称为节点）包含两部分：一部分用于存储数据，另一部分则是一个指针，指向下一个节点。这种设计使得元素之间...
数据结构实验报告 实验一 线性表链式存储运算的算法实现.docx
11-12
实验报告“数据结构实验报告 实验一 线性表链式存储运算的算法实现.docx”主要探讨了线性表在链式存储结构下的操作，包括建立、插入、删除和输出等基本算法的实现。以下是对这些知识点的详细解释： 一、线性表链式...
数据结构实验报告 实验一 线性表链式存储运算的算法实现 (2).docx
11-12
实验报告“数据结构实验报告 实验一 线性表链式存储运算的算法实现”主要探讨了在C语言环境下如何实现线性表的链式存储结构及其基本操作，包括链表的创建、插入、删除和输出。以下是相关知识点的详细说明： 1. **...
数据结构与算法，JAVA版，对广义表进行取表头，取表尾，判空，长度，深度，插入，删除第i个元素，删除广义表的所有元素。
04-20
数据结构与算法，JAVA版，对广义表进行取表头，取表尾，判空，长度，深度，插入，删除第i个元素，删除广义表的所有元素。
看数据结构写代码（52） 广义表的扩展线性链表存储表示
fuming0210sc的专栏
04-18 2063
广义表 的另一种 存储结构是 扩展线性链表存储表示，这种 存储结构的 根 节点 必 存在，并且 根节点的 表尾 为空，将 根节点的 表尾 放 在 表头 的 表尾 指针上。 这样 从 表头 一直 就可以 遍历 所有 同级 节点。 具体j结构 如下： 例如 下面的 广义表 ，用 扩展线性链表 表示为： 而 头尾 存储表示，是 把 表头 和 表尾 都放在 根节点 的 指针上。
基于层次遍历的非递归复制二叉链表
jy821695的专栏
06-10 1036
利用广义表非递归构造二叉树
jiefen111的专栏
12-21 722
#includeusing namespace std;const int nax=100;typedef struct tr{ int data,left,right; int label;}btree;btree tree[100];bool ck[100];int recreat(int *mid,int *post,int len)//len结点个数{ int i,j,root=0,tro
广义表的复制及C语言代码实现
数据结构和算法教程（C语言版）
03-17 704
对于任意一个非空广义表来说，都是由两部分组成：表头和表尾。反之，只要确定的一个广义表的表头和表尾，那么这个广义表就可以唯一确定下来。复制一个广义表，也是不断的复制表头和表尾的过程。如果表头或者表尾同样是一个广义表，依旧复制其表头和表尾。 所以，复制广义表的过程，其实就是不断的递归，复制广义表中表头和表尾的过程。 递归的出口有两个： 如果当前遍历的数据元素为空表，则直接返回空表。 如果当前遍历的...
广义表的java实现_广义表的复制详解（含C语言代码实现）
weixin_36429440的博客
02-28 193
对于任意一个非空广义表来说，都是由两部分组成：表头和表尾。反之，只要确定的一个广义表的表头和表尾，那么这个广义表就可以唯一确定下来。复制一个广义表，也是不断的复制表头和表尾的过程。如果表头或者表尾同样是一个广义表，依旧复制其表头和表尾。所以，复制广义表的过程，其实就是不断的递归，复制广义表中表头和表尾的过程。递归的出口有两个：如果当前遍历的数据元素为空表，则直接返回空表。如果当前遍历的数据元素为该...
数据结构30：广义表的复制
weixin_30662109的博客
05-15 231
对于任意一个非空广义表来说，都是由两部分组成：表头和表尾。反之，只要确定的一个广义表的表头和表尾，那么这个广义表就可以唯一确定下来。复制一个广义表，也是不断的复制表头和表尾的过程。如果表头或者表尾同样是一个广义表，依旧复制其表头和表尾。所以，复制广义表的过程，其实就是不断的递归，复制广义表中表头和表尾的过程。递归的出口有两个： 如果当前遍历的数据元素为空表，则直接返回空表。 如果当前遍历的...
广义表的非递归深度优先遍历及相关运算的c++实现
naturerun的博客
12-06 717
对广义表的链表表示的深度优先遍历的实现要点是,从广义表的附加头节点开始向后顺序访问，对原子节点，访问结束后递进至下一节点，每遇到子表的附加头节点就进入该子表所在的下一层继续向下遍历，在下一层的子表中同样也是访问并经过原子节点，一遇到子表附加头节点就立即向下进入子表继续遍历，就这样不断向下遍历，最终进入空表或没有子表的非空表并遍历完成后就立即回溯至上一层子表并按照上述规则继续向后遍历，子表遍历完成就再回溯至上上层子表，然后继续遍历，就这样反复不断地回溯和向下遍历，直到最后一次回溯至原广义表并向后完成遍历后整个
利用广义表建立二叉树+将树变成广义表形式输出+非递归的三种遍历+层序遍历难死个jb
_计算机好苦
09-21 804
#include<iostream> #include<stack> using namespace std; struct node { int data; node* left, * right; }; typedef node* list; list BuildTreeByLists(string cnt) { stack<list>s; list temp = NULL; list rootnode = NULL; int i = 0, k = 1;
C++实现线性表链式存储-单链表详解
C++实现线性表链式存储（单链），通过定义节点类和链表类，提供了链表的基本操作，包括构造、增、删、查、输出等功能。 在C++编程中，线性表是一种基本的数据结构，通常有顺序存储和链式存储两种方式。这里讨论的是...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值