一元多项式的加法、减法、乘法和微分运算的C语言链表结构算法实现

最新推荐文章于 2022-11-08 17:46:16 发布
最新推荐文章于 2022-11-08 17:46:16 发布
阅读量2.3k 收藏 27
点赞数 1
文章标签： c/c++ 数据结构与算法
原文链接：https://segmentfault.com/a/1190000017135539
版权

问题描述：

利用链表实现一元多项式的数学运算。如一元多项式

FkRkwT.png

可以利用其系数?和指数?组合的方式实现链式存储。通过对线性表的基本操作，例如插入，删除，查找等可以实现一元多项式的复杂运算，比如加，减，乘，除等运算。
基本要求：
利用链表存储一元多项式，通过对链表的操作实现多项式的运算。
测试数据：
对于多项式：?(?) = 7 + 3? + 9? + 5?，?(?) = 8? + 22? − 9?，实现加，减，乘和微分，输出结果。

解答：

实现思路：
代码结构为主分形式，主函数主要为一些提示，具体的输入输出则将参数传递到分函数中实现。分函数有创建一元多项式、多项式升幂排序、比较项指数大小、打印多项式、加法运算、减法运算、微分运算和乘法运算等。

比较需要关注的是乘法方面的实现，思路是将乘法运算分解为一系列的加法运算。不过在这里着实纠结了好多天，本来呢觉得实现乘法自己应该为它再另外构造一个加法算法提供接口，以便实现它的加法迭代。可是呢，这样完全行不通，打印出来的都是0.0，自己完全不晓得为什么，重复对着代码思考了好多次了，觉得没什么毛病，但就是行不通——

然后呢，大概是前天吧！自己捣弄了半天代码调试依旧不会的情况下，决定回归输出调试，于是就在乘法函数里注释掉了迭代用的加法，另外在加法循环体外面上头加了两句打印语句想看看多项式A和多项式B的每一项相乘后得到的结果是咋样的。

于是乎奇迹就诞生了，用x^1+2x^2+3x^3和x^1作为测试数据，莫名其妙地乘法结果就给打印出来了，完全没有用到我费了九牛二虎之力写出来的迭代加法——

不过显示结果还是有点小bug，显示出来的是正确结果的相反数，而且主函数返回值也不是正常的0，而是莫名其妙的3221225477

接着本着修bug的精神就在乘法函数里运算部分乘了个负一，这下结果就好看了，如下（返回值依旧不正常）

Fk2XTS.png

但是，天下怎么会有凭空掉馅饼这等好事！？自己再用上面给出的复杂测试数据跑了下，这下就没那么好看了，得出来的是一个明显错误的结果(。﹏。*)

FkRATU.png

而且也发现了微分算法部分的一个小bug——
好吧，只能后续继续改进了，自己应该是在指针理解上出现了问题，回头去《深入理解C指针》。
另外，假如用户输入的两个一元多项式为相同的话，输出也会有点不正常，需要弄弄。

看来有点眉目了

FkRGkD.png

11.25这天晚上，我终于弄明白了bug的缘由——丫蛋自己没把Pd给初始化！，而且打印函数如果给它的参数是个空地址的话，它会在那儿瞎转悠几圈，然后返回个不是0的返回值，直接结束程序——

（还修复了打印首项有时会出现加号的小bug）

还存在一个问题，就是如果输入的两个多项式是相同的话，减法那部分结果会不显示任何值，而不是0。得弄弄

（已解决）

OK，下面就贴下自己的代码了，折腾带注释版本，以及去掉无关注释~纯净版本^_^

实现代码（折腾注释版）：

#include<stdio.h>
#include<stdlib.h>

typedef struct term{
    float coef;
    int expn;
    struct term *next;
}term,*LinkList;

typedef LinkList polynomial;

int cmp(LinkList pa,LinkList pb)                //比较各项指数大小
{
    if(pa->expn > pb->expn)
        return 1;
    else if(pa->expn == pb->expn)
        return 0;
    else
        return -1;
}

int LocateElem(LinkList L,LinkList t,LinkList *q)    /*定位项数指数大小，使多项式按升幂排序               这里的*q起到内存保护的作用*/
{
    LinkList p1=L->next;
    LinkList p2=L;
    while(p1)
    {
        if(t->expn > p1->expn)
        {
            p1=p1->next;
            p2=p2->next;
        }
        else if(t->expn == p1->expn)
        {
            *q=p1;
            return 1;
        }
        else
        {
            *q=p2;
            return 0;
        }
    }
    

        *q=p2;
        return 0;

}

void CreatePolyn(polynomial P)                //建立多项式所需的各项具体值
{
    LinkList t;
    LinkList q;
    P->coef=0.0;
    P->expn=-1;
    P->next=NULL;
    printf("Please input coefficient and exponent below in format like 1,2 and end with 0,0:\n");

    t=(LinkList)malloc(sizeof(term));
   // if(!t) exit(OVERFLOW);   //借鉴教材《数据结构（C语言版）》的代码风格...没用
    t->next=NULL;
    scanf("%f,%d",&t->coef,&t->expn);
    while(t->coef||t->expn)            //约定0,0结束输入，实现动态输入多项式
    {
        if(!LocateElem(P,t,&q))           /*每次输入的指数都应不同，转移指针P->q,而且实现指数排序（这里 &q 博大精深， 利用指针的指针之妙法确保指针不被篡改，在LocateElem内部又机智地取回———）*/
        {
            t->next=q->next;                /*1.q->next = NULL,2.q->next = t，    也改变了P->next的值  P与q共享内存*/
            q->next=t;                      //对t, 头插法, 对q, 尾插法
        }
        
        t=(LinkList)malloc(sizeof(term));
         //  if(!t) exit(OVERFLOW);
        t->next=NULL;
        scanf("%f,%d",&t->coef,&t->expn);
    }

}


void printPolyn(polynomial P)                    //打印多项式
{
    LinkList q;
    q=P->next;
    
    if(!q)
    {
        printf("0\n");  //针对两多项式相同的情况
    }
    
    while(q)
    {
        if(q->coef==0)                    /*主要针对微分的常数项情况，可是出现了下一项变为首项但其前面加号没有去掉的情况。。。*/
        {
            printf("");
            q=q->next;    /*将此if结构与下面if结构分开，不耦合，解决打印首项带加号问题*/
        }
        
        if(q->expn==0)                         //判断指数是否为零及正负，调整输出格式
        {
            printf("%.2f",q->coef);
            q=q->next;
        }
        else if(q->expn>0)
        {
            printf("%.2f*x^%d",q->coef,q->expn);
            q=q->next;
        }
        else
        {
            printf("%.2f*x^(%d)",q->coef,q->expn);
            q=q->next;
        }

        if(q)                            //判断下一项系数正负，调整输出格式
        {
            if(q->coef>0)
                printf("+");
            else
                printf("");
        }
        else
            printf("\n");
    }
}

void AddPolyn(polynomial Pa,polynomial Pb,polynomial Pc)    /*不完全参照教科书上的思路，而是另外开辟空间存储和，不释放原来数据空间*/
{
    LinkList qa=Pa->next;
    LinkList qb=Pb->next;
    LinkList qc=Pc;
    LinkList head=qc;
    LinkList s;
    float sum; 

    Pc->coef=0.0;
    Pc->expn=-1;
    Pc->next=NULL;

    while(qa&&qb)
    {
        switch(cmp(qa,qb))
        {
            case -1:
                s=(LinkList)malloc(sizeof(term));
                   //if(!s) exit(OVERFLOW);
                *s=*qa;
                qc->next=s;
                qc=s;
                qa=qa->next;
                break;
            case 0:
                sum=qa->coef+qb->coef;
                if(sum!=0.0)
                {
        
                    s=(LinkList)malloc(sizeof(term));
                       //if(!s) exit(OVERFLOW);
                    *s=*qa;
                    s->coef=sum;

                    qc->next=s;
                    qc=s;
                    qa=qa->next;
                    qb=qb->next;

                }
                else
                {
    
                    qc->next=qa->next;
                    qa=qa->next;
                    qb=qb->next;
        
                }
                break;
            case 1:
                s=(LinkList)malloc(sizeof(term));
                //  if(!s) exit(OVERFLOW);
                *s=*qb;   
                qc->next=s;
                qc=s;
                qb=qb->next;
                break;
        }
    }
    qc->next=qa?qa:qb;    //添加NULL尾巴
    Pc=head;

}


void SubPolyn(polynomial Pa,polynomial Pb,polynomial Pc)   /*思路同前面加法，减法变加法，前面加负号，  另外开辟空间存储差*/
{
    LinkList qa=Pa->next;
    LinkList qb=Pb->next;
    LinkList qc=Pc;
    LinkList head=qc;
    LinkList s;
    float differ; 

    Pc->coef=0.0;
    Pc->expn=-1;
    Pc->next=NULL;

    while(qb)          //为减数加负号
    {
        qb->coef=0-(qb->coef);
        qb=qb->next;
    }

    qb=Pb->next;

    while(qa&&qb)
    {
        switch(cmp(qa,qb))
        {
            case -1:
                s=(LinkList)malloc(sizeof(term));
                //   if(!s) exit(OVERFLOW);
                *s=*qa;
                qc->next=s;
                qc=s;
                qa=qa->next;
                break;
            case 0:
                differ=qa->coef+qb->coef;
                if(differ!=0.0)
                {
                
                    s=(LinkList)malloc(sizeof(term));
                    //   if(!s) exit(OVERFLOW);
                    *s=*qa;
                    s->coef=differ;
                    qc->next=s;
                    qc=s;
                    qa=qa->next;
                    qb=qb->next;
                
                }
                else
                {
                
                    qc->next=qa->next;
                    qa=qa->next;
                    qb=qb->next;
            
                }
                break;
            case 1:
                s=(LinkList)malloc(sizeof(term));
                 //  if(!s) exit(OVERFLOW);
                *s=*qb;
               
                qc->next=s;
                qc=s;
                qb=qb->next;
                break;
        }
    }
    qc->next=qa?qa:qb;
    Pc=head;

}



void AddPolyn_multi(polynomial Pa,polynomial Pb)    /*构造一个可以用于乘法项数迭代的特殊加法,释放空间，和储存至Pa，方便迭代累加*/
{
    LinkList qa=Pa->next;        //这两句导致项数错位了？
    LinkList qb=Pb->next;
    //LinkList qa=Pa;
    //LinkList qb=Pb;
    LinkList qc=Pa;
    LinkList head=qc;
    LinkList s,s1,s2;
    float sum;

    while(qa&&qb)
    {
        switch(cmp(qa,qb))
        {
            case -1:
                qc->next=qa;
                qc=qa;
                qa=qa->next;
                break;
            case 0:
                sum=qa->coef+qb->coef;
                if(sum!=0.0)
                {
                    s=qb;
                    qa->coef=sum;
                    qc->next=qa;
                    qc=qa;
                    qa=qa->next;
                    qb=qb->next;
                    free(s);
                }
                else
                {
                    s1=qa;
                    s2=qb;
                    qc->next=qa->next;
                    qa=qa->next;
                    qb=qb->next;
                    free(s1);
                    free(s2);
                }
                break;
            case 1:
                qc->next=qb;
                qc=qb;
                qb=qb->next;
                break;
        }
    }
    qc->next=qa?qa:qb;
    Pa=head;   //千思万虑老子终于把你给揪出来了，原来是形参搞得鬼！？
    //printPolyn(Pa);
    //pirntf("\n");
//    free(Pb);     /*这句语句挺有问题，要是该指数项唯有Pb才有呢，相加后依然链接到Pb的内存空间上 */
}

    
void MultiPolyn(polynomial Pa,polynomial Pb,polynomial Pc)       /*乘法运算，分解为一系列的加法运算*/
{
    LinkList qa=Pa->next;
    LinkList qb=Pb->next;
    // LinkList qc=Pc;
    LinkList head;
    LinkList qd;
    LinkList t[20],d[20],h[20];/*,s1,s2;  这些结构体指针数组所对应的空间也应该为它们加个指数值为负一的内存！ 有啊！！！*/ 
    int i,j;
    //float product; 
    
    /******下面添加的这两句由于思考疏忽耗费了我大半个月的精力********/
    Pc->coef=0.0;
    Pc->expn=-1;
    Pc->next=NULL;
    
    /******以上*********/
    
    
    while(qa&&qb)
    {
        
        for(j=0;j<20;j++)
        {
            d[j]=(LinkList)malloc(sizeof(term));
              // if(!d[j]) exit(OVERFLOW);
            d[j]->coef=0.0;
            d[j]->expn=-1; 
            d[j]->next=NULL;
            h[j]=d[j];
            qd=qa;

            for(i=0;i<20;i++)                      /*二维数组应该有两个中括号吧？  不，不用，用了指针 */
            {
                //leave it alone!
                
                t[i]=(LinkList)malloc(sizeof(term));
                //   if(!t[i]) exit(OVERFLOW);
                *t[i]=*qd;
                t[i]->coef=(qd->coef)*(qb->coef)*(-1);
                t[i]->expn=qd->expn+qb->expn;
                
                
                d[j]->next=t[i];
                
                d[j]=t[i];
                qd=qd->next;
                if(!qd)
                {
                    d[j]->next=NULL; 
                    break;
                }
            }


            qb=qb->next;
            if(!qb)
            {    
                h[j+1]=NULL;
                break;
            }
        }
    }

    //printPolyn(h[0]);
    //printPolyn(h[1]);
    //printPolyn(h[2]);
    //printPolyn(h[3]);
    /*非常奇怪，加了这两句就可以运行乘法了，不过打印出来的却是相反数，而且返回值不是0，而是3221225477 
                //现在不用那个特殊加法也可以了！？难道是因为我创建的那伪二维数组实现了地址的复用？？？
                测试发现，如果碰到空地址,比如这个h[3]，会进入一段时间死循环。。。果不其然
                                    //自己应该是在指针的理解上出现了一些问题，得去攻读下o'reilly的《深入理解c指针》了 */
     
                         //Not effective???
                 
    for(j=0;j<20;j++)                  //对了，每一列指数值不一定相同的吖！ 
    {
        if(!h[j+1])            //原来是你把我辛辛苦苦生成的结果的头指针给改了的#.#
        {
            head=h[j];
            break;        //不，不是它的错，是下面的Pc->next出现了两个-1指数项！
        }
//        printPolyn(h[j+1]);
        AddPolyn_multi(h[j+1],h[j]);
        head=h[j+1];
    }

    // qc->next=qa?qa:qb;
    Pc->next=head;        //擦!你丫蛋没初始化就跑进来了
    //free(Pb);            /*乘法部分逻辑上是没什么问题的咯，问题应该是出现在构造加法那里，哪里没有接上 */
}                            //（后来补充）看来不是构造加法问题


void diff(polynomial Pa, polynomial Pb)
{
    LinkList qa=Pa->next;
    LinkList head;
    
    Pb->coef=0.0;
    Pb->expn=-1;
    Pb->next=NULL;
    head=Pb;
//    Pb=Pb->next;

    while(qa)
    {
        Pb->next=(LinkList)malloc(sizeof(term));
         //  if(!Pb->next) exit(OVERFLOW);
        Pb=Pb->next;
        Pb->coef=(qa->coef)*(float)(qa->expn);   //coef和expn类型不同，需要进行类型转化
        Pb->expn=qa->expn-1;
        Pb->next=NULL;
        qa=qa->next;
        
    }
    
    Pb=head;
}



int main()
{
    polynomial Pa;
    polynomial Pb;
    polynomial Pc;
    polynomial Pd;
    Pa=(LinkList)malloc(sizeof(term));
    Pb=(LinkList)malloc(sizeof(term));
    Pc=(LinkList)malloc(sizeof(term));
//    Pc->next=NULL;
    Pd=(LinkList)malloc(sizeof(term));
//    Pd->next=NULL;

    CreatePolyn(Pa);
    printf("Pa=");
    printPolyn(Pa);
    CreatePolyn(Pb);
    printf("Pb=");
    printPolyn(Pb);
/*    Pc = Pa;
    Pd = Pb;
*/
    printf("\nPa'=");
    diff(Pa,Pc);
    printPolyn(Pc);

    printf("Pa+Pb=");
    AddPolyn(Pa,Pb,Pc);
    printPolyn(Pc);

    printf("Pa-Pb=");
    SubPolyn(Pa,Pb,Pc);
    printPolyn(Pc);


    
    printf("Pa*Pb=");
    MultiPolyn(Pa,Pb,Pd);
    printPolyn(Pd);
//    printf("\n");
 


/*    printf("Pb'=");
    diff(Pb,Pc);
    printPolyn(Pc);

*/
    return 0;
实现代码（纯净版）：
#include<stdio.h>
#include<stdlib.h>

typedef struct term{
    float coef;
    int expn;
    struct term *next;
}term,*LinkList;

typedef LinkList polynomial;

int cmp(LinkList pa,LinkList pb)
{
    if(pa->expn > pb->expn)
        return 1;
    else if(pa->expn == pb->expn)
        return 0;
    else 
        return -1;
}

int LocateElem(LinkList L,LinkList t,LinkList *q)
{
    LinkList p1=L->next;
    LinkList p2=L;
    while(p1)
    {
        if(t->expn > p1->expn)
        {
            p1=p1->next;
            p2=p2->next;
        }
        else if(t->expn == p1->expn)
        {
            *q=p1;
            return 1;
        }
        else 
        {
            *q=p2;
            return 0;
        }
    }

    *q=p2;
    return 0;
}

void CreatePolyn(polynomial P)
{
    LinkList t;
    LinkList q;
    P->coef=0.0;
    P->expn=-1;
    P->next=NULL;
    printf("Please input coefficient and exponent in format like 1,2 and end with 0,0 :\n");

    t=(LinkList)malloc(sizeof(term));
    t->next=NULL;
    scanf("%f,%d",&t->coef,&t->expn);
    while(t->coef||t->expn)
    {
        if(!LocateElem(P,t,&q))
            {
                t->next=q->next;
                q->next=t;
            }

        t=(LinkList)malloc(sizeof(term));
        t->next=NULL;
        scanf("%f,%d",&t->coef,&t->expn);
    }
}



void printPolyn(polynomial P)
{
    LinkList q;
    q=P->next;

    if(!q)
    {
        printf("0\n");
    }

    while(q)
    {
        if(q->coef==0)
        {
            printf("");
            q=q->next;

        }

        if(q->expn==0)
        {
            printf("%.2f",q->coef);
            q=q->next;
        }
        else if(q->expn>0)
        {
            printf("%.2f*x^%d",q->coef,q->expn);
            q=q->next;
        }
        else 
        {
            printf("%.2f*x^(%d)",q->coef,q->expn);
            q=q->next;
        }



        if(q)
        {
            if(q->coef>0)
                printf("+");
            else
                printf("");
        }
        else
            printf("\n");
    }
}


void AddPolyn(polynomial Pa,polynomial Pb,polynomial Pc)
{
    LinkList qa=Pa->next;
    LinkList qb=Pb->next;
    LinkList qc=Pc;
    LinkList head=qc;
    LinkList s;
    float sum;

    Pc->coef=0.0;
    Pc->expn=-1;
    Pc->next=NULL;

    while(qa&&qb)
        {
            switch(cmp(qa,qb))
            {
                case -1:
                    s=(LinkList)malloc(sizeof(term));
                    *s=*qa;
                    qc->next=s;
                    qc=s;
                    qa=qa->next;
                    break;
                case 0:
                    sum=qa->coef+qb->coef;
                    if(sum!=0.0)
                    {
                        s=(LinkList)malloc(sizeof(term));
                        *s=*qa;
                        s->coef=sum;
                        qc->next=s;
                        qc=s;
                        qa=qa->next;
                        qb=qb->next;

                    }
                    else
                    {
                        qc->next=qa->next;
                        qa=qa->next;
                        qb=qb->next;
                    }
                    break;
                case 1:
                    s=(LinkList)malloc(sizeof(term));
                    *s=*qb;
                    qc->next=s;
                    qc=s;
                    qb=qb->next;
                    break;
            }
        }
        qc->next=qa?qa:qb;
        Pc=head;

}

void SubPolyn(polynomial Pa,polynomial Pb,polynomial Pc)
{
    LinkList qa=Pa->next;
    LinkList qb=Pb->next;
    LinkList qc=Pc;
    LinkList head=qc;
    LinkList s;
    float differ;

    Pc->coef=0.0;
    Pc->expn=-1;
    Pc->next=NULL;

    while(qb)
    {
        qb->coef=0-(qb->coef);
        qb=qb->next;
    }

    qb=Pb->next;

    while(qa&&qb)
    {
        switch(cmp(qa,qb))
        {
            case -1:
                s=(LinkList)malloc(sizeof(term));
                *s=*qa;
                qc->next=s;
                qc=s;
                qa=qa->next;
                break;
            case 0:
                differ=qa->coef+qb->coef;
                if(differ!=0.0)
                {
                    s=(LinkList)malloc(sizeof(term));
                    *s=*qa;
                    s->coef=differ;
                    qc->next=s;
                    qc=s;
                    qa=qa->next;
                    qb=qb->next;
                }
                else
                {
                    qc->next=qa->next;
                    qa=qa->next;
                    qb=qb->next;

                }
                break;
            case 1:
                s=(LinkList)malloc(sizeof(term));
                *s=*qb;
                qc->next=s;
                qc=s;
                qb=qb->next;
                break;
        }
    }
    qc->next=qa?qa:qb;
    Pc=head;
}

void diff(polynomial Pa,polynomial Pb)
{
    LinkList qa=Pa->next;
    LinkList head;
    Pb->coef=0.0;
    Pb->expn=-1;
    Pb->next=NULL;
    head=Pb;

    while(qa)
    {
        Pb->next=(LinkList)malloc(sizeof(term));
        Pb=Pb->next;
        Pb->coef=(qa->coef)*(float)(qa->expn);
        Pb->expn=qa->expn-1;
        Pb->next=NULL;
        qa=qa->next;
    }

    Pb=head;
}



void AddPolyn_multi(polynomial Pa,polynomial Pb)
{
    LinkList qa=Pa->next;
    LinkList qb=Pb->next;
    LinkList qc=qa;
    LinkList head=qc;
    LinkList s,s1,s2;
    float sum;

    while(qa&&qb)
    {
        switch(cmp(qa,qb))
        {
            case -1:
                qc->next=qa;
                qc=qa;
                qa=qa->next;
                break;
            case 0:
                sum=qa->coef+qb->coef;
                if(sum!=0.0)
                {
                    s=qb;
                    qa->coef=sum;
                    qc->next=qa;
                    qc=qa;
                    qa=qa->next;
                    qb=qb->next;
                    free(s);
                }
                else
                {
                    s1=qa;
                    s2=qb;
                    qc->next=qa->next;
                    qa=qa->next;
                    qb=qb->next;
                    free(s1);
                    free(s2);
                }
                break;
            case 1:
                qc->next=qb;
                qc=qb;
                qb=qb->next;
                break;

        }
    }
    qc->next=qa?qa:qb;
    Pa=head;

}



void MultiPolyn(polynomial Pa,polynomial Pb,polynomial Pc)
{
    LinkList qa=Pa->next;
    LinkList qb=Pb->next;
    LinkList head;
    LinkList qd;
    LinkList t[20],d[20],h[20];
    int i,j;

    Pc->coef=0.0;
    Pc->expn=-1;
    Pc->next=NULL;

    while(qa&&qb)
    {
        for(j=0;j<20;j++)
        {
            d[j]=(LinkList)malloc(sizeof(term));
            d[j]->coef=0.0;
            d[j]->expn=-1;
            d[j]->next=NULL;
            h[j]=d[j];
            qd=qa;

            for(i=0;i<20;i++)
            {
                t[i]=(LinkList)malloc(sizeof(term));
                *t[i]=*qd;
                t[i]->coef=(qd->coef)*(qb->coef)*(-1);
                t[i]->expn=qd->expn+qb->expn;
                d[j]->next=t[i];
                d[j]=t[i];
                qd=qd->next;
                if(!qd)
                {
                    d[j]->next=NULL;
                    break;
                }

            }

            qb=qb->next;
            if(!qb)
            {
                h[j+1]=NULL;
                break;
            }
        }
    }

    for(j=0;j<20;j++)
    {
        if(!h[j+1])
        {
            head=h[j];
            break;
        }
        AddPolyn_multi(h[j+1],h[j]);
        head=h[j+1];        
        
    }

    Pc->next=head;

}


int main()
{
    polynomial Pa;
    polynomial Pb;
    polynomial Pc;
    polynomial Pd;
    Pa=(LinkList)malloc(sizeof(term));
    Pb=(LinkList)malloc(sizeof(term));
    Pc=(LinkList)malloc(sizeof(term));

    Pd=(LinkList)malloc(sizeof(term));


    CreatePolyn(Pa);
    printf("Pa=");
    printPolyn(Pa);
    CreatePolyn(Pb);
    printf("Pb=");
    printPolyn(Pb);

    printf("\nPa'=");
    diff(Pa,Pc);
    printPolyn(Pc);

    printf("Pa+Pb=");
    AddPolyn(Pa,Pb,Pc);
    printPolyn(Pc);

    printf("Pa-Pb=");
    SubPolyn(Pa,Pb,Pc);
    printPolyn(Pc);


    
    printf("Pa*Pb=");
    MultiPolyn(Pa,Pb,Pd);
    printPolyn(Pd);

    return 0;
}
运行结果：

FkRRcn.png

参考文章：
利用单链表实现一元多项式的表示及相加

有序链表一元多项式C实例

Polynomial multiplication using linked list in C

Fkosrd.jpg

weixin_34124577
关注
  • 1
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
一元多项式的加法和乘法 c语言
whr
04-14 4510
一元多项式的加法和乘法（C语言链表实现） 题目 总体结构： main函数ReadPolyAttachAddMultcomparePrintPoly 各函数解释： 函数名 负责功能 ReadPoly 读入数据 Attach 将数据构建成链表 Add 多项式相加 Mult 多项式相乘 compare 比较 PrintPoly 打印结果 代码 #include&l...
c语言实现的多项式加法
10-20
这个程序很简单，是一次作业，但我想好好学习c语言，所以上传了
C语言：多项式加法
Yearn_You的博客
07-09 2611
题目内容： 一个多项式可以表达为x的各次幂与系数乘积的和，比如： 2x6+3x5+12x3+6x+20 现在，你的程序要读入两个多项式，然后输出这两个多项式的和，也就是把对应的幂上的系数相加然后输出。 程序要处理的幂最大为100。 输入格式: 总共要输入两个多项式，每个多项式的输入格式如下： 每行输入两个数字，第一个表示幂次，第二个表示该幂次的系数，所有的系数都是整数。第一行一定是最高幂，最后一行...
C语言求解微分方程
weixin_39742350的博客
11-08 1456
1.简单欧拉积分实现 2.龙哥库塔发 （未完待续）
C语言：一元多项式加减法运算（链表 附答案）.docx
10-26
《C语言实现一元多项式加减法运算的链表方法》 在计算机科学中，数据结构和算法是解决问题的基础工具。本篇文章将探讨如何使用C语言通过链表实现一元多项式的加减法运算。这是一道适合初学者的链表实践题目，通过这...
顺序结构、动态链表结构下的一元多项式的加法、减法、乘法的实现。.docx
11-05
本文档是关于一元多项式加法、减法和乘法实现的课程设计报告，主要关注在顺序结构和动态链表结构下的实现方法。设计目标是加深对数据结构的理解，尤其是如何选择合适的数据结构来解决问题，并能编写相关算法。设计...
数据结构课程设计-一元多项式加法、减法、乘法运算的实现.doc
最新发布
11-28
数据结构课程设计-一元多项式加法、减法、乘法运算的实现.doc
数据结构课程设计—一元多项式加法减法乘法运算的实现.pdf
12-01
本文档主要介绍了一元多项式的加法、减法和乘法运算的实现，涉及数据结构课程设计的内容。设计目标是使用顺序存储结构和链式存储结构来处理多项式的运算，并用C语言进行编程实现。 首先，设计内容包括两部分： 1. ...
顺序链式一元多项式加法,减法,乘法运算的实现.pdf
11-05
在本实验中，我们将使用顺序存储结构和链式存储结构来实现一元多项式的加法、减法、乘法运算。例如，给定两个一元多项式f(x) = 8x^6 + 5x^5 - 10x^4 + 32x^2 - x + 10和g(x) = 7x^5 + 10x^4 - 20x^3 - 10x^2 + x，...
一元多项式的相加、相减、相乘、相除
04-07
利用C++编写的关于实现一元多项式的相加操作，包括相加、相减，相乘，相除等
链表实现多项式加法和乘法（C语言实现）
12-03
使用链表实现多项式的加法和乘法，数据结构常见问题的C语言实现
一元多项式的运算（加减乘）终极版
12-02
这是使用C语言写成。实现了一元多项式的加减乘的运算。我们使用计算机处理的对象之间通常存在着的是一种最简单的线性关系，这类数学模型可称为线性的数据结构。而数据存储结构有两种：顺序存储结构和链式存储结构。线性表是最常用且最简单的一种数据结构。所以我们做的是———–一元多项式的表示及相加，其过程其实是对线性标的操作。实验结构和链接存储结构上的运算以及熟练运用掌握的线性表的操作，实现一元n次多项式的目的是掌握线性表的基本操作，插入、删除、查找，以及线性表合并等运算在顺序存储的加法运算。学习实现一元n次多项式的加法是符号多项式的操作，是表处理的典型用例，需要注意的是：顺序存储结构指的是用数组方法，使用数组方法实现时，在插入和删除的方面，数组不如链表灵活，方法复杂，删除其中一个需要将其后的数组元素改变位置，使其数组保持原有的顺序结构，在查找方面较链表简单，只需要知道其下标就可以知道。链接存储结构指的是用链表方法,值得注意的是，删除和插入较为灵活，不需要变动大多数元素，但是查找过程相对于数组这种顺序存储结构来说较为复杂，耗时巨大。
02-线性结构2 一元多项式的乘法与加法运算（C/C++)
叶柖的博客
03-12 2466
#include &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; #include &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;stdlib.h&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; #include &amp;amp;amp;a
C语言数据结构实现——一元多项式的基本运算
热门推荐
mcr1379673758的博客
03-17 1万+
该算法使用C语言的数据结构知识实现一元多项式的基本运算（加法、减法、乘法）。
一元多项式的加法和乘法运算
yyf_blog
04-11 647
多项式的表示：仅表示非零项 数组：编程简单、调试容易、但需要事先确定数组的大小 链表：动态性强、编程略微复杂、调试困难 一种比较好的实现方法：动态数组 用链表结构解决该问题： typedef struct PolyNode *Polynomial; struct PolyNode{ int coef;//系数 int expon;//指数 Polynomia...
一元多项式的乘法与加法运算（c++实现）
weixin_42403281的博客
03-07 2462
原题为PTA数据结构mooc的线性表作业第二题，题目如下： 本人是c++初学者，代码还是感觉有点费劲，大家轻拍砖。整个程序的逻辑就是四个函数组成，分别Read()函数读取输入多项式信息并形成链表，printchain()函数打印链表，chainplus()函数实现两个链表的加法，chainmult()函数实现两个链表的乘法。在设计乘法函数时，在其中也调用了加法函数进行计算。 #include&...
实现一元多项式加法、减法、乘法运算的数据结构设计
在本文中，我们将讨论如何使用顺序存储结构和链式存储结构实现一元多项式的加法、减法、乘法运算，并且使用C语言编程实现实验内容中的结构定义和算法。 1. 一元多项式加法、减法、乘法运算的实现 一元多项式加法、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值