线性表ADT应用：一元多项式的处理

最新推荐文章于 2024-05-08 16:03:03 发布
最新推荐文章于 2024-05-08 16:03:03 发布
阅读量437 收藏 2
点赞数
分类专栏： 栈 c++ 文章标签： 链表 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/one_big_River/article/details/105332029
版权
c++ 同时被 2 个专栏收录
6 篇文章 0 订阅
订阅专栏
栈
3 篇文章 0 订阅
订阅专栏

线性表ADT应用：一元多项式的处理

符号处理是一类非数值性问题，一元多项式就是符号处理的一类实例。一个一元n次多项式的一般形式如下：

Pn(x) = p1Xe1 + p2Xe2 +…+ pmXem
其中 p1,p2,…, pm为各项的系数，非零；
e1,e2,…, em 为各项的指数，满足0<e1 <e2 <… <em，即按指数升序

现要求在计算机中存储这样的多项式，并能对它们进行处理。除了输入、输出外，还应包括加法、减法、乘法等等操作。

注：存储结构可以采用顺序存储结构（只存储系数方式、存储系数和指数方式）、链式存储结构（单链、循环单链、双链、循环双链），自己确定存储方案并在代码的前面用注释说明。

程序实现时采用菜单控制，通过菜单符号选择要执行的操作。

  1. 创建多项式C ：分别创建两个多项式A(x)和B(x)，其中 输入时按照 指数的升序顺序输入多项式每一项的系数和指数，系数为0表示多项式结束。

    例如：输入 ：

1 2 3 4 5 6 7 8 0
2 3 4 5 6 7 0

则创建多项式分别为：

A(x)=x2+3x4+5x6+7x8
B(x)=2x3+4x5+6x^7

  1. 多项式加法P：计算C(x) = A(x) + B(x)，并输出C(x)

  2. 多项式减法S： 计算C(x) = A(x) - B(x)，并输出C(x)

  3. 多项式乘法M： 计算C(x) = A(x) * B(x)，并输出C(x)

  4. 求导数D： 计算C(x) = A’(x)，并输出C(x)

  5. 求值V：计算x=x0时 多项式的值 A(x0)，并输出（保留两位小数）。其中x0是输入的一个 float型数

  6. 多项式置空F：清空A(x)、B(x)、C(x)三个多项式，释放空间

  7. 退出X： 结束操作

测试用例
粘贴的时候总是有错误

#include "stdlib.h"
#include "iostream"
#include <cmath>
#include <iomanip>
using namespace std ;
class List; //前视定义,否则友元无法定义
struct xiang
{
    int zhi;
    int xi;
};
class LinkNode
{
    friend  List; //链表结点类的定义


public:
    LinkNode *link;
    int data;
    int zhishu;
    LinkNode(const int & item,const int & item2, LinkNode *ptr = NULL)
    {
        data=item;
        zhishu=item2;
        link=ptr;
    }

    LinkNode (LinkNode *ptr = NULL)
    {
        link=ptr;
    }
    ~LinkNode() {};

};

class List
{
    //单链表类的定义

public:
    LinkNode *first; //指向首结点的指针
    List ()
    {
        first = new LinkNode ();   // 带头结点
    }
    ~List ()
    {
        MakeEmpty();   //析构函数
    }
    void MakeEmpty ( );      //链表置空
    void input(int endtag);
    void output();
    //static void plusit(List A,List B,List* C);          //+
    static void jianfa(List A,List B,List* C);

};
void List:: MakeEmpty ( )
{
    LinkNode *q;
    while (  first->link != NULL )
    {
        q = first->link;
        first->link = q->link;
        delete q;
    }
};

//输入
void List::input(int endtag)
{
    LinkNode *newnode,*r;
    int val1,val2;
    first=new LinkNode();

    if(first==NULL)
    {
        cerr<<"存储分配错误！"<<endl;
        exit(1);
    }
    cin>>val1;    //读入元素
    r=first;  //r总指向目前链表的最后一个节点
    while(val1!=endtag)
    {
        cin>>val2;
        newnode=new LinkNode(val1,val2);
        r->link=newnode;
        r=newnode;
        cin>>val1;

    }
    r->link=NULL;
}


void List ::output()
{
    LinkNode *q = first->link;
    int flag=0;
    while(q != NULL)
    {
        if(q== first->link)      //第一个数字的系数不需要加符号
        {
            if(q->data==1)         //-----如果第一个系数是1
            {
                if(q->zhishu==0)    //指数为0时，只输出这个1
                {
                    cout<<"1";
                    flag=1;
                }
                else
                {
                    cout<<"x^"<<q->zhishu;
                    flag=1;
                    q = q->link;
                    continue;
                }
            }
            if(q->data==0)           //----如果系数是零，不用输出
            {

            }
            else                       //----不是零也不是1的，正常输出
            {
                if(q->zhishu==0)
                {
                    cout<<q->data;
                    flag=1;

                }
                else
                {
                    cout<<q->data<<"x^"<<q->zhishu;
                    flag=1;
                    q = q->link;
                    continue;
                }

            }
        }
        else
        {
            if(q->data>0)                  //出了第一项的，其他的要加符号
            {
                if(q->data==1)              //---第一项是1
                {

                    cout<<"+x^"<<q->zhishu;
                    flag=1;
                }
                else
                {
                    cout<<"+"<<q->data<<"x^"<<q->zhishu;
                    flag=1;
                }
            }
            else if(q->data<0)
            {
                cout<<q->data<<"x^"<<q->zhishu;
                flag=1;
            }
            else if(q->data==0)
            {

            }

        }
        q = q->link;
    }
    if(flag==0)
        cout<<"0";
    cout<<endl;
}

int main()
{
    int endtag=0;
    List A,B;
    List C,D,E,F;
    char v;
    cin>>v;
    if(v=='C')
    {
        A.input(endtag);
        B.input(endtag);
        //A.output();
        // B.output();
    }
    while(1)
    {
        cin>>v;
        if(v=='X')
        {
            break;
        }
        if(v=='P')               //加法
        {
            LinkNode *newnode;
            LinkNode *p2,*q2,*j;
            p2=A.first->link;
            q2=B.first->link;
            j=C.first;
            while(p2!=NULL || q2!=NULL)
            {
                if(p2!=NULL && q2!=NULL)
                {
                    if(p2->zhishu==q2->zhishu)
                    {
                        newnode=new LinkNode();
                        newnode->zhishu=p2->zhishu;
                        newnode->data=(p2->data)+(q2->data);
                        j->link=newnode;
                        j=newnode;
                        p2=p2->link;
                        q2=q2->link;
                        continue;
                    }
                    if(p2->zhishu>q2->zhishu)
                    {
                        newnode=new LinkNode();
                        newnode->zhishu=q2->zhishu;
                        newnode->data=q2->data;
                        j->link=newnode;
                        j=newnode;
                        q2=q2->link;
                        continue;
                    }
                    if(p2->zhishu<q2->zhishu)
                    {
                        newnode=new LinkNode();
                        newnode->zhishu=p2->zhishu;
                        newnode->data=p2->data;
                        j->link=newnode;
                        j=newnode;
                        p2=p2->link;
                        continue;
                    }
                }
                else if(p2==NULL)
                {
                    newnode=new LinkNode();
                    newnode->zhishu=q2->zhishu;
                    newnode->data=q2->data;
                    j->link=newnode;
                    j=newnode;
                    q2=q2->link;
                    continue;
                }
                else if(q2==NULL)
                {
                    newnode=new LinkNode();
                    newnode->zhishu=p2->zhishu;
                    newnode->data=p2->data;
                    j->link=newnode;
                    j=newnode;
                    p2=p2->link;
                    continue;
                }
            }
            cout<<"C(x)=";
            C.output();
            free(p2);
            free(q2);

        }
        if(v=='S')
        {
            LinkNode *newnode;
            LinkNode *p,*q,*j;
            p=A.first->link;
            q=B.first->link;
            j=D.first;
            while(p!=NULL || q!=NULL)
            {
                if(p!=NULL && q!=NULL)
                {
                    if(p->zhishu==q->zhishu)
                    {
                        newnode=new LinkNode();
                        newnode->zhishu=p->zhishu;
                        newnode->data=(p->data)-(q->data);
                        j->link=newnode;
                        j=newnode;
                        p=p->link;
                        q=q->link;
                        continue;
                    }
                    if(p->zhishu>q->zhishu)
                    {
                        newnode=new LinkNode();
                        newnode->zhishu=q->zhishu;
                        newnode->data=-(q->data);
                        j->link=newnode;
                        j=newnode;
                        q=q->link;
                        continue;
                    }
                    if(p->zhishu<q->zhishu)
                    {
                        newnode=new LinkNode();
                        newnode->zhishu=p->zhishu;
                        newnode->data=p->data;
                        j->link=newnode;
                        j=newnode;
                        p=p->link;
                        continue;
                    }
                }
                else if(p==NULL)
                {
                    newnode=new LinkNode();
                    newnode->zhishu=q->zhishu;
                    newnode->data=-(q->data);
                    j->link=newnode;
                    j=newnode;
                    q=q->link;
                    continue;
                }
                else if(q==NULL)
                {
                    newnode=new LinkNode();
                    newnode->zhishu=p->zhishu;
                    newnode->data=p->data;
                    j->link=newnode;
                    j=newnode;
                    p=p->link;
                    continue;
                }
            }
            cout<<"C(x)=";
            D.output();
            free(p);
            free(q);

        }
        if(v=='M')
        {
            int is0=0;
            xiang xiangshu[100];
            int k=0,flag=-1;
            LinkNode *p3,*q3;
            p3=A.first->link;
            q3=B.first->link;
            while(p3!=NULL)
            {
                q3=B.first->link;
                while(q3!=NULL)
                {
                    flag=-1;
                    for(int i=0; i<k; i++)
                    {
                        if(xiangshu[i].zhi==(p3->zhishu)+(q3->zhishu))
                        {
                            xiangshu[i].xi=xiangshu[i].xi+((p3->data)*(q3->data));
                            flag=1;
                            break;
                        }
                    }
                    if(flag==-1)
                    {
                        xiangshu[k].xi=(p3->data)*(q3->data);
                        xiangshu[k].zhi=(p3->zhishu)+(q3->zhishu);
                        k++;
                    }
                    q3=q3->link;
                }
                p3=p3->link;
            }
            //排序
            xiang t;
            for(int i=0; i<k; i++)
            {
                for(int j=i+1; j<k; j++)
                {
                    if(xiangshu[i].zhi>xiangshu[j].zhi)
                    {
                        t=xiangshu[i];
                        xiangshu[i]=xiangshu[j];
                        xiangshu[j]=t;
                    }
                }
            }
            cout<<"C(x)=";
            for(int i=0; i<k; i++)
            {
                if(i==0)
                {
                    if(xiangshu[i].xi==1)
                    {
                        if(xiangshu[i].zhi==1)
                        {
                            cout<<"x";
                            is0=1;
                        }
                        else
                        {
                            cout<<"x^"<<xiangshu[i].zhi;
                            is0=1;
                        }

                    }
                    else
                    {
                        if(xiangshu[i].zhi==1)
                        {
                            cout<<xiangshu[i].xi<<"x";
                            is0=1;
                        }
                        else
                        {
                            cout<<xiangshu[i].xi<<"x^"<<xiangshu[i].zhi;
                            is0=1;
                        }
                    }
                }
                else
                {
                    if(xiangshu[i].xi>0)
                    {
                        if(xiangshu[i].xi==1)
                        {
                            if(xiangshu[i].zhi==1)
                            {
                                cout<<"+x";
                                is0=1;
                            }
                            else
                            {
                                cout<<"+x^"<<xiangshu[i].zhi;
                                is0=1;
                            }

                        }
                        else
                        {
                            if(xiangshu[i].zhi==1)
                            {
                                cout<<"+"<<xiangshu[i].xi<<"x";

                                is0=1;
                            }
                            else
                            {
                                cout<<"+"<<xiangshu[i].xi<<"x^"<<xiangshu[i].zhi;
                                is0=1;
                            }
                        }
                    }
                    else if(xiangshu[i].xi<0)
                    {
                        if(xiangshu[i].zhi==1)
                        {
                            cout<<xiangshu[i].xi<<"x";
                            is0=1;
                        }
                        else
                        {
                            cout<<xiangshu[i].xi<<"x^"<<xiangshu[i].zhi;
                            is0=1;
                        }
                    }
                }

            }
            if(is0==0)
                cout<<"0";           cout<<endl;

        }
        if(v=='D')
        {
            int is00=0;
            int jishu=0;
            xiang qiudao[100];
            LinkNode *p4;
            p4=A.first->link;
            while(p4!=NULL)
            {
                if(p4->zhishu==0)
                {
                     p4=p4->link;
                }
                else
                {
                    qiudao[jishu].xi=(p4->data)*(p4->zhishu);
                    qiudao[jishu].zhi=(p4->zhishu)-1;
                    jishu++;
                    p4=p4->link;
                }

            }
            cout<<"C(x)=";
            for(int i=0; i<jishu; i++)
            {
                if(i==0)
                {
                    if(qiudao[i].xi==1)
                    {
                        if(qiudao[i].zhi==1)
                        {
                            cout<<"x";
                            is00=1;
                        }
                        else if(qiudao[i].zhi==0)
                        {
                            cout<<"1";
                            is00=1;
                        }
                        else
                        {
                            cout<<"x^"<<qiudao[i].zhi;
                            is00=1;
                        }

                    }
                    else if(qiudao[i].xi==0)
                    {

                    }
                    else
                    {
                        if(qiudao[i].zhi==1)
                        {
                            cout<<qiudao[i].xi<<"x";
                            is00=1;
                        }
                        else if(qiudao[i].zhi==0)
                        {
                            cout<<qiudao[i].xi;
                            is00=1;
                        }
                        else
                        {
                            cout<<qiudao[i].xi<<"x^"<<qiudao[i].zhi;
                            is00=1;
                        }
                    }
                }
                else
                {
                    if(qiudao[i].xi>0)
                    {
                        if(qiudao[i].xi==1)
                        {
                            if(qiudao[i].zhi==1)
                            {
                                cout<<"+x";
                                is00=1;
                            }
                            else if(qiudao[i].zhi==0)
                            {
                                cout<<"1";
                                is00=1;
                            }
                            else
                            {
                                cout<<"+x^"<<qiudao[i].zhi;
                                is00=1;
                            }

                        }
                        else
                        {
                            if(qiudao[i].zhi==1)
                            {
                                cout<<"+"<<qiudao[i].xi<<"x";
                                is00=1;
                            }
                            else if(qiudao[i].zhi==0)
                            {
                                cout<<"+"<<qiudao[i].xi;
                                is00=1;
                            }
                            else
                            {
                                cout<<"+"<<qiudao[i].xi<<"x^"<<qiudao[i].zhi;
                                is00=1;
                            }
                        }
                    }
                    else if(qiudao[i].xi<0)
                    {
                        if(qiudao[i].zhi==1)
                        {
                            cout<<qiudao[i].xi<<"x";
                            is00=1;
                        }
                        else if(qiudao[i].zhi==0)
                        {
                            cout<<qiudao[i].xi;
                            is00=1;
                        }
                        else
                        {
                            cout<<qiudao[i].xi<<"x^"<<qiudao[i].zhi;
                            is00=1;
                        }
                    }
                    else if(qiudao[i].xi==0)
                    {

                    }
                }

            }
            if(is00==0)
                cout<<"0";
            cout<<endl;

        }
        if(v=='V')
        {
            float com,sum=0;
            cin>>com;
            LinkNode *p5;
            p5=A.first->link;
            while(p5!=NULL)
            {
                sum=sum+(p5->data)*pow(com,p5->zhishu);
                p5 = p5->link;
            }
            cout<<fixed<<setprecision(2)<<sum<<endl;
        }
        if(v=='C')
        {
            A.MakeEmpty();
            B.MakeEmpty();
            C.MakeEmpty();
            D.MakeEmpty();
        }

    }

    return 0;
}
易
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构与算法】多项式ADT
grefwfdxz
06-13 2018
多项式ADT 定义一种一元(具有非负次幂)多项式的抽象数据类型, F(X)=∑i=0NAiXiF(X)=∑i=0NAiXi F(X) = \sum_{i=0}^NA_iX^i 对于大部分系数为0的多项式,可以使用一个简单数组来储存这些系数.之后进行加减乘除等操作. //数组实现声明 typedef struct{ int CoeffArray[ NaxDegree + ...
有序链表ADT模板简单应用算法设计：一元多项式的加/减法运算（10.24节快乐）(我想找个女朋友)
Blackoutdragon的博客
10-24 1129
文章目录问题描述输入说明输出说明输入样例输出样例问题分析问题重点思路分析 问题描述 目的：使用C++模板设计单链表的抽象数据类型（ADT）。并在此基础上，稍加改动，针对一元多项式建立相应的稀疏多项式ADT，使用单链表ADT的基本操作，设计并实现稀疏一元多项式的加法计算的算法设计。 内容：（1）请参照单链表的ADT模板，设计稀疏一元多项式的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考网盘中的单链表AD
有序链表ADT模板简单应用算法设计：一元多项式的加/减法运算
最新发布
的博客
05-08 847
LinkNode(const ElemType1 &item1, const ElemType2 &item2, LinkNode<ElemType1, ElemType2> *ptr = NULL) //构造函数2，用于构造其他结点。并在此基础上，稍加改动，针对一元多项式建立相应的稀疏多项式ADT，使用单链表ADT的基本操作，设计并实现稀疏一元多项式的加法计算的算法设计。假定：系数项的数据类型为double，指数项的数据类型为int，指数项递增有序，多项式至少有1项，系数项均不为0。
如何处理格式不规范的一元多项式_一元积分（一）
weixin_39631316的博客
11-27 129
coffee最近在复习重积分、曲线积分、曲面积分和常微分方程，时常会用到一元积分，然而距coffee学一元积分已有快一年时间了，有些积分公式早已忘得一干二净。所以我们就以一元积分作为本专栏的开头吧。然而从题头也可以看出，积分公式多得可以写成一本书。除了题头图片展示的《常用积分表》（中国科学技术大学出版社）外，coffee还推荐另一本书：《积分的方法与技巧》（中国科学技术大学出版社）。coffee翻...
如何处理格式不规范的一元多项式_多项式I：带余除法与整除
weixin_39658716的博客
12-05 697
本节我们就考研中常考的两点，多项式的带余除法与整除关系进行分析讲解，并且给出大家在考研中，是如何应用带余除法和整除，并且给大家补充了n次单位根的的知识，在其解决整除问题中的应用，大家务必要熟练掌握！！！定理1：（带余除法）对于任意的 则存在唯一的使得岩宝小提示：对于带余除法的证明，请大家务必熟悉，有的多项式证明的题目就直接利用带余除法证明的原理进行说明，详见北大课本第九页. 【例1】已知 求...
1011 A+B 和 C (15 分)
见见大魔王
08-29 146
1011A+B 和 C(15分)给定区间 [−231,231] 内的 3 个整数A、B和C，请判断A+B是否大于C。输入格式：输入第 1 行给出正整数T(≤10)，...
用线性表实现一个一元多项式Polynomial
11-22
该源程序是数据结构的代码实现：用线性表实现一个一元多项式Polynomial
利用线性表实现一个一元多项式
12-07
能够实现一元多项式的输入和输出 能够进行一元多项式相加 能够进行一元多项式相减 能够计算一元多项式在x处的值 能够计算一元多项式的导数（选作） 能够进行一元多项式相乘 编写main ()函数测试算法的正确性
一元多项式
12-16
菜鸟代码
哈工大数据结构实验一_一元多项式计算器
03-26
实验项目：线性表的链式存储结构与应用 实验题目：一元多项式计算器 实验内容： 设计线性表的动态或者静态链式存储结构，并实现一个一元多项式的计算器。 实验要求： 以动态或者静态链表存储一元多项式，在此基础上...
C/C++:一元多项式的表示及其运算.rar(含注释)
03-04
符号多项式的操作，已经成为表处理的典型用例。在数学上，一个一元多项式Pn(x)可按升幂写 ...本题要求选用线性表的一种合适的存储结构来表示一个一元多项式，并在此结构上实现一元多 项式的加法，减法和乘法操作
求一元n次多项式的值java实现
03-04
用java实现 求一元n次多项式的值 里面有算法 和源码 算法为秦朝韶 算法
一元多项式求和，结果按降幂输出
04-25
一元多项式求和，结果按降幂输出 c语言
如何处理格式不规范的一元多项式_Word VBA 改题库，假期管孩子不放松
weixin_39662594的博客
11-21 211
时值端午，虽然假期只有三天，但也可以让大家在紧张的工作中稍微透一口气。不过对于已经在电脑前度过一个学期的孩子们来说，小长假恐怕也放松不得，因为马上就要进入疫情后的第一次期末考试了。孩子考试，家长当然也不会轻松。这不，昨天一位朋友就跟我说：老师在群里发了一套初一代数的例题模板（Word文件），让家长自己在此基础上，随便修改每道题的数字系数和加减号，以便同学反复练习整式化简的技巧。听到这里，马上明白了...
如何处理格式不规范的一元多项式_数学技巧||十字交叉法解一元三次方程——个人高中偶然发现的一个数学技巧...
weixin_39860583的博客
12-05 685
相信大家对于高中的生活，想必经历过的都还想在经历一次，十分怀念高中时期的生活，整天把自己堆在题海里，每天都过得很充实，身边一群可爱的人儿，无话不谈，无话不说，没有什么忧虑与顾忌，每一天都是美好的一天。闲话就不多说了，直接进入今天的话题，大致就是个人高中时期偶然发现的一个规律，想把它分享给大家，希望能够帮助到大家，如果大家认为这个方法可行的话，也可以分享给自己的弟弟妹妹或者其他有需要的人。双十字法参...
c语言一元稀疏多项式的加法,一元稀疏多项式计算器C语言课程设计.doc
weixin_39961522的博客
05-22 667
实用标准文档大全实用标准文档大全学号20142014-2015学年 第二学期《软件工程》课程设计报告题目：一元稀疏多项式计算器专业：计算机科学与技术班级：计算机科学与技术(2)班姓名：指导教师：成绩：TOC \o "1-3" \h \z \u 一、问题描述 3二、 需求分析 3三、概要设计 4四、详细设计 5五、 源代码 6六 、程序测试 18七、 使用说明 24八、 课设总结 25一、问题描...
单链表应用------一元多项式
cc52xx的博客
03-16 1067
单链表应用------一元多项式 单链表应用------一元多项式 【问题描述】编写一个程序用单链表存储多项式，并实现两个一元多项式A与B相加的函数。A，B刚开始是升序的，A与B之和按降序排列。例如： 多项式A: 1.2X^0 2.5X^1 3.2X^3 -2.5X^5 多项式B: -1.2X^0 2.5X^1 3.2X^3 2.5X^5 5.4X^10 多项式A与B之和：5...
抽象数据结构（ADT）的介绍
热铁皮屋上的猫的博客
11-30 6117
前言： 抽象数据类型（ADT（abstract data type））是一些操作的集合。抽象数据类型是数学的抽象；在ADT的定义中根本没有涉及如何实现操作的集合。 整数，实数及布尔量有与它们相关的操作，而抽象数据类型也有自己额相关操作。对于集合ADT，有并，交，测定大小，曲玉等操作。 表，栈和队列 表 操作： 插入，删除，查找… 应用： 多项式ADT（一元多项式） 基数排序（线形时间排序） 多重...
线性表应用三：集合测试数据
06-08
好的，以下是一些可能的集合测试数据： 1. 空集合 2. 单元素集合：{1}、{"apple"}、{true} 等等 3. 多元素集合：{1, 2, 3}、{true, false, true}、{"apple", "banana", "orange"} 等等 4. 非重复元素集合：{1, 2, 3...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值