（更新以及bug修复）多项式的减法以及乘法，通过链表形式实现

最新推荐文章于 2024-09-11 20:39:26 发布
最新推荐文章于 2024-09-11 20:39:26 发布
阅读量92 收藏
点赞数 1
文章标签： 链表 数据结构 算法 c语言 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73997107/article/details/128781104
版权

继上一篇多项式加法带来多项式减法以及多项式乘法的实现。同时修复了上篇文章的一个bug

在建立链表的时候上篇文章有一个分类如下

else if(xnum[0]!=0&&xnum[0]!=1)

此时会带来以下的问题，即当输入的第一项的系数为十以内的正整数时无法正常运行

此时，我们只需将此行代码改为

else if((xnum[0]!=0&&jiajian[0]!=0)||(xnum[0]!=0&&xnum[0]!=1))

问题就被完美解决了，是不是一个good ball了呢（野球帝王师傅乱串bushi)

接着我们来看减法，减法与加法的思路一样，唯一要注意的一点就是在减法的时候区分减数和被减数，废话不多说，我们直接放代码

SLNode* pnodeSUT(SLNode* pnodeA, SLNode* pnodeB){
        SLNode *pnodeC,*p,*q,*r,*s;
        float x;
        p=pnodeA;
        q=pnodeB;
        pnodeC=(SLNode*)malloc(LEN);
        r=pnodeC;
        while(p!=NULL&&q!=NULL){
            if(p->exp==q->exp){
                x=p->coef-q->coef;
                if(x!=0){
                    s=(SLNode*)malloc(LEN);
                    s->coef=x;
                    s->exp=p->exp;
                    r->next=s;
                    r=s;
                }
                p=p->next;
                q=q->next;
            }
            else 
                if(p-> exp> q-> exp) {
                        s=(SLNode *)malloc(LEN);
                        s-> coef=p-> coef;
                        s-> exp=p-> exp;
                        r-> next=s;
                        r=s;
                        p=p-> next;
                     }
                else                 {
                        s=(SLNode*)malloc(LEN);
                        s-> coef=q-> coef;
                        s-> exp=q-> exp;
                        r-> next=s;
                        r=s;
                        q=q-> next;
                     }    
        }
        while(p!=NULL){
            s=(SLNode *)malloc(LEN);
            s->coef=p->coef;
            s->exp=p->exp;
            r->next=s;
            r=s;
            p=p->next;    
        }
        while(q!=NULL)   {                                                 /*复制pnodeA余下的部分*/
                s=(SLNode*)malloc(LEN);                         /*新开辟的一个内存单元,复制一个结点s*/
                s-> coef=(q-> coef)*(-1);
                s-> exp=q-> exp;
                r-> next=s;  
                r=s;                    
                q=q-> next;                                                     /*p指向下一个结点*/
        }
        r->next=NULL;
        s=pnodeC;                                                               /*删除pnodeC的头结点*/
        pnodeC=pnodeC-> next;
        free(s);                                                                 /*释放s所指向的内存空间*/
        return(pnodeC);        
}

接着我们来看乘法，首先思路是把两个多项式依次乘起来，先不进行合并同类项，接着写一个函数用于系数的排序，最后合并同类项即可。

我们先来看交换的代码（指的是值交换，而非结点的交换）

void change(SLNode*p,SLNode*q){
    float ct;
    int et;
    ct = p->coef;
    p->coef = q->coef;
    q->coef = ct;
    et = p->exp;
    p->exp = q->exp;
    q->exp = et;
}

接着是合并

SLNode* pnodeMULT(SLNode* pnodeA, SLNode* pnodeB){
    SLNode *pnodeC,*p,*q,*r,*s;
        float x,y;
        p=pnodeA;
        pnodeC=(SLNode*)malloc(LEN);
        r=pnodeC;
        while(p!=NULL){
            q=pnodeB;//这里要注意q的位置要放在两个while之间，这样才能完全遍历两个多项式的乘法
            while(q!=NULL){
                x=(p->coef)*(q->coef);
                y=(p->exp)+(q->exp);
                    s=(SLNode*)malloc(LEN);
                    s->coef=x;
                    s->exp=y;
                    r->next=s;
                    r=s;
                    q=q->next;
            }
            p=p->next;
        }
        r->next=NULL;
        s=pnodeC;                                                     /*删除pnodeC的头结点*/
        pnodeC=pnodeC-> next;
        free(s); 
    SLNode*p1;
    p1 = pnodeC;
        while ((p1->next) != NULL) {
            if ((p1->exp) < (p1->next->exp)) {
                change(p1, p1->next);
            }
            p1 = p1->next;
        }
        SLNode *q1;
    for (q1 = pnodeC; q1 != NULL&&q1->next != NULL;){
            if ((q1->exp) == (q1->next->exp)) {
                q1->coef += q1->next->coef;
                q1->next = q1->next->next;
            }
            else q1 = q1->next;         
    }
    return(pnodeC);
}

先排序再合并同类项的目的在于能够大大简化合并时的代码实现的难度

最后附上这次实验的完整代码

#include   <stdlib.h>
#include   <malloc.h>
#include   <stdio.h>
#include <string.h>
#include <conio.h>
#define   LEN     sizeof(SLNode)
typedef   struct   Node{
        int   coef;                                                  
        int   exp;                                                
        struct Node* next;                          
}SLNode;
 
SLNode* creat(void);  
void print(SLNode* head);
SLNode* pnodeADD(SLNode* pnodeA, SLNode* pnodeB);
SLNode* pnodeSUT(SLNode* pnodeA, SLNode* pnodeB);
SLNode* pnodeMULT(SLNode* pnodeA, SLNode* pnodeB);
void   main(void)
{
        SLNode* pnodeA,*pnodeB,*pnodeC,*pnodeD,*pnodeE;/*定义三个SLNode结构体型的指针变量*/
         printf( "Add two univariate polynomials\n ");
         printf( "Substruct two univariate polynomials\n ");
         printf( "Multiplication two univariate polynomials\n ");
        printf( "Please enter the first polynomial\n ");
        pnodeA=creat();                                     /*调用函数creat(),输入一元多项式pnodeA*的系数和指数,建立链表*/
        printf( "First polynomial:\n ");
        print(pnodeA);                                       /*调用函数print(),  输出一元多项式pnodeA*/
        printf( "\nPlease enter the second polynomial:\n ");
        pnodeB=creat();                                     /*调用函数creat(),输入一元多项式pnodeB*的系数和指数,建立链表*/
        printf( "Second polynomial:\n ");
        print(pnodeB);                                       /*调用函数print(),输出一元多项式pnodeB*/
        pnodeC=pnodeADD(pnodeA,pnodeB);     /*调用函数pnodeADD,实现一元多项式相加*/
        pnodeD=pnodeSUT(pnodeA,pnodeB);
        pnodeE=pnodeMULT(pnodeA,pnodeB);
        printf( "\nAdd two polynomials:\n ");
        print(pnodeC);                                       /*调用函数print(),输出相加结果pondeC*/
        printf("\n");
        printf( "\nSubtract two polynomials:\n ");
        print(pnodeD);
        printf( "\n ");
        printf("\nMultiplication two polynomials:\n");
        print(pnodeE);
        printf("\n");
}
SLNode*creat(void){
       SLNode*head,*p1,*p2;                          /*定义SLNode结构体类型的指针变量*/
       int n=0,xnum[100],xx=0,jiajian[100],jj=0,chengf[100],cc=0;                                                      /*n初始为0*/            
       p1=p2=(SLNode*)malloc(LEN);          
       char a[1000];
       gets(a);                                                            
       head=NULL;                                                  /*把头指针定义为空*/    
       while(a[n])                              /*系数不为空时,执行循环*/
                  {                                     
                           if(a[n]=='x')  {xnum[xx]=n; xx++;}
                           if(a[n]=='+'||a[n]=='-')  {jiajian[jj]=n; jj++;}
                           if(a[n]=='^')  {chengf[cc]=n; cc++;}
                           n++;
                  }
//对于第一项
                if(xnum[0]==0)  
                    p1-> coef=1;
                if(jiajian[0]==0&&xnum[0]==1)
                    p1-> coef=-1;
                else if((xnum[0]!=0&&jiajian[0]!=0)||(xnum[0]!=0&&xnum[0]!=1))
                    {
                      for(int ll=0;ll<xnum[0];ll++)
                        { 
                          if(ll==0)
                            {
                                    if(a[ll]>='0'&&a[ll]<='9')  p1-> coef=a[ll]-'0';
                                    if(a[ll]=='+')              p1-> coef=0;
                                    if(a[ll]=='-')              p1-> coef=0;
                            }
                          else                                  p1-> coef= (p1-> coef)*10+a[ll]-'0';
                           }
                     if(a[0]=='+')                     p1-> coef=(p1-> coef)*1;
                     if(a[0]=='-')                     p1-> coef=(p1-> coef)*(-1);
                    }
                  int jiajian1;
                  if((a[0]>='0'&&a[0]<='9')||xnum[0]==0)      jiajian1=jiajian[0];
                  else                                        jiajian1=jiajian[1];                           
                  for(int ll=chengf[0]+1;ll<jiajian1;ll++)
                  {
                    if(ll==chengf[0]+1)   p1-> exp=a[ll]-'0';
                    else                  p1-> exp= (p1-> exp)*10+a[ll]-'0';
                  }
                  head=p1;
                  p2=p1;
                  p1=(SLNode*)malloc(LEN);
//对于中间的项
                for(int tt=1;tt<xx-1;tt++)
                  {
                    int jiajian2;
                    if(a[0]=='+'||a[0]=='-')      jiajian2=jiajian[tt];     //判断第一个输入的是否是加减符号
                    else                          jiajian2=jiajian[tt-1];  
                if(jiajian2+1==xnum[tt])
                    p1-> coef=1;
                else{
                    for(int lt=jiajian2+1;lt<xnum[tt];lt++)
                  {
                    if(lt==jiajian2+1)        p1-> coef=a[lt]-'0';
                    else                      p1-> coef= (p1-> coef)*10+a[lt]-'0';
                  }
              }
                if(a[0]>='0'&&a[0]<='9')      
                  {
                    if(a[jiajian[tt-1]]=='+')       p1->coef= (p1->coef)*1;
                    if(a[jiajian[tt-1]]=='-')       p1->coef= (p1-> coef)*(-1);
                  }
                else                          
                  {
                    if(a[jiajian[tt]]=='+')       p1-> coef= (p1-> coef)*1;
                    if(a[jiajian[tt]]=='-')       p1-> coef= (p1-> coef)*(-1);
                  }
                 int jiajianmidexp;
                 if(a[0]=='+'||a[0]=='-')      jiajianmidexp=jiajian[tt+1];     //判断第一个输入的是否是加减符号
                 else                          jiajianmidexp=jiajian[tt];  
                 for(int lt=chengf[tt]+1;lt<jiajianmidexp;lt++)
                  {
                    if(lt==chengf[tt]+1)   p1-> exp=a[lt]-'0';
                    else                   p1-> exp= (p1-> exp)*10+a[lt]-'0';
                  }
             p2-> next=p1;
             p2=p1;
             p1=(SLNode*)malloc(LEN);                      
       }
   //对于最后一项  
   //-x^5+x^4+x^3+x^2 is able
            int jiajian3;
            if((a[0]>='0'&&a[0]<='9')||xnum[0]==0)      jiajian3=jiajian[xx-2];
            else                                        jiajian3=jiajian[xx-1];
              if(jiajian3+1==xnum[xx-1])
                    p1-> coef=1; 
              else{ 
              for(int lt=jiajian3+1;lt<xnum[xx-1];lt++)
               { 
                if(lt==jiajian3+1)   p1-> coef=a[lt]-'0';
                else                 p1-> coef= (p1-> coef)*10+a[lt]-'0';
                }
               } 
            if(a[jiajian3]=='+')      p1-> coef = (p1-> coef)*1;
            if(a[jiajian3]=='-')      p1-> coef = (p1-> coef)*(-1);
            if(jj==xx-1||(jiajian[0]==0&&jj==xx)){ 
             if(cc==xx){
              for(int lt=chengf[xx-1]+1;lt<n;lt++)
               {
                 if(lt==chengf[xx-1]+1)   p1-> exp=a[lt]-'0';
                 else                     p1-> exp= (p1-> exp)*10+a[lt]-'0';
               }
              } 
             else  p1->exp=1; 
             p2-> next=p1;
             p2=p1;
             //p1=(SLNode*)malloc(LEN);
             p2-> next=NULL;                                          /*置结束标志为NULL*/
             return(head);
            }
            if(jj==xx+1||(jj==xx&&jiajian[0]!=0)){
             if(cc==xx){
              for(int lt=chengf[xx-1]+1;lt<jiajian[jj-1];lt++)
               {
                 if(lt==chengf[xx-1]+1)   p1-> exp=a[lt]-'0';
                 else                     p1-> exp= (p1-> exp)*10+a[lt]-'0';
               }
              } 
             else  p1->exp=1;
             p2-> next=p1;
             p2=p1;
             p1=(SLNode*)malloc(LEN);
             p1->exp=0;
             for(int ww=jiajian[jj-1]+1;ww<n;ww++){
                 if(ww==jiajian[jj-1]+1)   p1->coef=a[ww]-'0';
                 else                      p1->coef=(p1->coef)*10+a[ww]-'0';
             }
             if(a[jiajian[jj-1]]=='+')      p1-> coef = (p1-> coef)*1;
             if(a[jiajian[jj-1]]=='-')      p1-> coef = (p1-> coef)*(-1);
             p2->next=p1;
             p2=p1;
             p2-> next=NULL;                                          /*置结束标志为NULL*/
             return(head);
            }
            
            }
                                                    /*返回值为头指针的地址*/
 
 
SLNode* pnodeADD(SLNode* pnodeA,SLNode* pnodeB){
        SLNode*pnodeC,*p,*q,*s,*r;                           /*定义SLNode结构体类型的指针变量*/
        float x;                                                                                
        p=pnodeA;                                                               /*p指向pnodeA的头结点*/
        q=pnodeB;                                                               /*q指向pnodeB的头结点*/
        pnodeC=(SLNode*)malloc(LEN);                         /*pnodeC指向新开辟的内存单元*/
        r=pnodeC;                                                                
        while(p!=NULL&&q!=NULL){
            if(p-> exp==q-> exp)   {                                 /*两结点指数相等时,将两系数相加生成新结点插入C中          */      
                        x=p-> coef+q-> coef;                             /*系数相加*/        
                        if(x!=0){                                              
                                s=(SLNode*)malloc(LEN);
                                s-> coef=x;
                                s-> exp=p-> exp;                            
                                r-> next=s;                                    
                                r=s;
            }
                        p=p-> next;
                        q=q-> next;
          }
            else                                                                 /*两结点的指数不相等时,将其中较小系数的结点复制成一个新的结点插入C中*/
                        if(p-> exp> q-> exp)
      {
                        s=(SLNode *)malloc(LEN);
                        s-> coef=p-> coef;
                        s-> exp=p-> exp;
                        r-> next=s;
                        r=s;
                        p=p-> next;
          }
                else   {
                        s=(SLNode*)malloc(LEN);
                        s-> coef=q-> coef;
                        s-> exp=q-> exp;
                        r-> next=s;
                        r=s;
                        q=q-> next;
          }
               
        }
        while(p!=NULL)   {                                                 /*复制pnodeA余下的部分*/
                s=(SLNode*)malloc(LEN);                         /*新开辟的一个内存单元,复制一个结点s*/
                s-> coef=p-> coef;                                          
                s-> exp=p-> exp;
                r-> next=s;  
                r=s;
                p=p-> next;                                                     /*p指向下一个结点*/
        }
        while(q!=NULL)   {                                                 /*复制pnodeA余下的部分*/
                s=(SLNode*)malloc(LEN);                         /*新开辟的一个内存单元,复制一个结点s*/
                s-> coef=q-> coef;
                s-> exp=q-> exp;
                r-> next=s;  
                r=s;                    
                q=q-> next;                                                     /*p指向下一个结点*/
        }
        r-> next=NULL;                                                       /*置结束标志为NULL*/
        s=pnodeC;                                                               /*删除pnodeC的头结点*/
        pnodeC=pnodeC-> next;
        free(s);                                                                 /*释放s所指向的内存空间*/
        return(pnodeC);                                                  
}

SLNode* pnodeSUT(SLNode* pnodeA, SLNode* pnodeB){
        SLNode *pnodeC,*p,*q,*r,*s;
        float x;
        p=pnodeA;
        q=pnodeB;
        pnodeC=(SLNode*)malloc(LEN);
        r=pnodeC;
        while(p!=NULL&&q!=NULL){
            if(p->exp==q->exp){
                x=p->coef-q->coef;
                if(x!=0){
                    s=(SLNode*)malloc(LEN);
                    s->coef=x;
                    s->exp=p->exp;
                    r->next=s;
                    r=s;
                }
                p=p->next;
                q=q->next;
            }
            else 
                if(p-> exp> q-> exp) {
                        s=(SLNode *)malloc(LEN);
                        s-> coef=p-> coef;
                        s-> exp=p-> exp;
                        r-> next=s;
                        r=s;
                        p=p-> next;
                     }
                else                 {
                        s=(SLNode*)malloc(LEN);
                        s-> coef=q-> coef;
                        s-> exp=q-> exp;
                        r-> next=s;
                        r=s;
                        q=q-> next;
                     }    
        }
        while(p!=NULL){
            s=(SLNode *)malloc(LEN);
            s->coef=p->coef;
            s->exp=p->exp;
            r->next=s;
            r=s;
            p=p->next;    
        }
        while(q!=NULL)   {                                                 /*复制pnodeA余下的部分*/
                s=(SLNode*)malloc(LEN);                         /*新开辟的一个内存单元,复制一个结点s*/
                s-> coef=(q-> coef)*(-1);
                s-> exp=q-> exp;
                r-> next=s;  
                r=s;                    
                q=q-> next;                                                     /*p指向下一个结点*/
        }
        r->next=NULL;
        s=pnodeC;                                                               /*删除pnodeC的头结点*/
        pnodeC=pnodeC-> next;
        free(s);                                                                 /*释放s所指向的内存空间*/
        return(pnodeC);        
}
void change(SLNode*p,SLNode*q){
    float ct;
    int et;
    ct = p->coef;
    p->coef = q->coef;
    q->coef = ct;
    et = p->exp;
    p->exp = q->exp;
    q->exp = et;
}
SLNode* pnodeMULT(SLNode* pnodeA, SLNode* pnodeB){
    SLNode *pnodeC,*p,*q,*r,*s;
        float x,y;
        p=pnodeA;
        pnodeC=(SLNode*)malloc(LEN);
        r=pnodeC;
        while(p!=NULL){
            q=pnodeB;
            while(q!=NULL){
                x=(p->coef)*(q->coef);
                y=(p->exp)+(q->exp);
                    s=(SLNode*)malloc(LEN);
                    s->coef=x;
                    s->exp=y;
                    r->next=s;
                    r=s;
                    q=q->next;
            }
            p=p->next;
        }
        r->next=NULL;
        s=pnodeC;                                                               /*删除pnodeC的头结点*/
        pnodeC=pnodeC-> next;
        free(s); 

    SLNode*p1;
    p1 = pnodeC;
        while ((p1->next) != NULL) {
            if ((p1->exp) < (p1->next->exp)) {
                change(p1, p1->next);
            }
            p1 = p1->next;
        }
        SLNode *q1;
    for (q1 = pnodeC; q1 != NULL&&q1->next != NULL;){
            if ((q1->exp) == (q1->next->exp)) {
                q1->coef += q1->next->coef;
                q1->next = q1->next->next;
            }
            else q1 = q1->next;
    }
    return(pnodeC);
}

void   print(SLNode* head){                    
        SLNode* p;                                                                     /*定义SLNode结构体类型的指针变量*/
       p=head;                                                                             /*把头指针的地址赋给p*/
        if(head!=NULL){
         if(p-> coef==1&&p-> exp!=0&&p-> exp!=1)
           printf( "x^%d",p-> exp);
         if(p-> coef==-1&&p-> exp!=0&&p-> exp!=1)
           printf( "-x^%d",p-> exp);
         if(p-> coef==1&&p-> exp==0)
           printf( "1");
         if(p-> coef==-1&&p-> exp==0)
           printf( "-1");
         if(p-> coef==-1&&p-> exp==1)
           printf( "-x");
         if(p-> coef==1&&p-> exp==1)
           printf( "x");
         if(p-> coef!=-1&&p-> coef!=1&&p-> exp==0)  
           printf( "%d",p-> coef);
         if(p-> coef!=1&&p-> coef!=-1&&p-> exp==1)
           printf( "%dx",p-> coef);
         if(p-> coef!=1&&p-> coef!=-1&&p-> coef!=0&&p-> exp!=0&&p-> exp!=1&&p-> exp!=-1)
            printf( "%dx^%d",p-> coef,p-> exp);
        p=p-> next;
    }
do{      
         if(p-> coef> 1)    
            printf("+");
         if(p-> coef==1&&p-> exp!=0&&p-> exp!=1)
            printf( "+x^%d",p-> exp);
         if(p-> coef==1&&p-> exp==0)
            printf( "+1");
         if(p-> coef==-1&&p-> exp!=0&&p-> exp!=1)
            printf( "-x^%d",p-> exp);
         if(p-> coef==-1&&p-> exp==1)
            printf( "-x");
         if(p-> coef==1&&p-> exp==1)
            printf( "+x");
         if(p-> coef==-1&&p-> exp==0)
            printf( "-1");
         if(p-> coef!=-1&&p-> coef!=1&&p-> exp==0)  
            printf( "%d",p-> coef);
         if(p-> coef!=1&&p-> coef!=-1&&p-> exp==1)
            printf( "%dx",p-> coef);
         else if(p-> coef!=1&&p-> coef!=-1&&p-> coef!=0&&p-> exp!=0&&p-> exp!=1)
            printf( "%dx^%d",p-> coef,p-> exp);
       p=p-> next;
}while(p!=NULL);
        }

感谢您的观看，有用的话希望点赞收藏加关注呀！谢谢大家

南游北归
关注
题解：一元多项式输入、输出、运算（基于链表)
jr_wwwsy的博客
03-19 3185
一元多项式（基于链表）之间的简单运算，实现过程中出现的一些bug
双向链表及其应用——实现多项式的加法及乘法
10-23
本文将深入探讨双向链表的实现以及它在一项特殊应用中的体现：一元多项式的加法与乘法运算。 首先，我们要理解双向链表的概念。双向链表是一种线性数据结构，每个节点包含两个指针，分别指向其前一个节点和后一个...
c语言 一元多项式乘法,一元多项式的加法、减法、乘法和微分运算的C语言链表结构算法实现...
weixin_36151775的博客
05-17 1055
问题描述：利用链表实现一元多项式的数学运算。如一元多项式可以利用其系数????和指数????组合的方式实现链式存储。通过对线性表的基本操作，例如插入，删除，查找等可以实现一元多项式的复杂运算，比如加，减，乘，除等运算。基本要求：利用链表存储一元多项式，通过对链表的操作实现多项式的运算。测试数据：对于多项式：????(????) = 7 + 3???? + 9???? + 5????，????(????) = 8???? + 22???? − 9????，实现加，减，乘...
C语言链表实现一元多项式运算器相关功能
weixin_73004416的博客
10-11 728
实验内容：（要求：禁止使用STL库)1输入并创建多项式(按指数升序或降序排列，系数浮点型，指数整型）；2. 输出多项式，项数+每项系数指数（按指数升序或降序排列）；3. 加法；4. 减法；5. 求值；6. 销毁；7. 清空；8.修改（①插入新的结点、②删除已有结点、③修改已有结点的系数）；9. 微分（N阶导数）；10. 不定积分；11. 定积分；12. 乘法和乘方；13. 除法；14. 四则运算。
c语言 两个一元多项式的乘法,一元多项式的加法、减法、乘法和微分运算的C语言链表结构算法实现...
weixin_42394656的博客
05-17 904
问题描述：利用链表实现一元多项式的数学运算。如一元多项式可以利用其系数????和指数????组合的方式实现链式存储。通过对线性表的基本操作，例如插入，删除，查找等可以实现一元多项式的复杂运算，比如加，减，乘，除等运算。基本要求：利用链表存储一元多项式，通过对链表的操作实现多项式的运算。测试数据：对于多项式：????(????) = 7 + 3???? + 9???? + 5????，????(????) = 8???? + 22???? − 9????，实现加，减，乘...
一元多项式的加法、减法、乘法和微分运算的C语言链表结构算法实现
weixin_34124577的博客
11-25 2349
问题描述： 利用链表实现一元多项式的数学运算。如一元多项式 可以利用其系数
c语言 一元多项式乘法,[内附完整源码和文档] 基于C语言实现的一元多项式的计算...
weixin_31062993的博客
05-17 1030
一、概述通过C语言使用链式存储结构实现一元多项式加法、减法和乘法的运算。按指数降序排列。二、需求分析建立一元多项式并按照指数降序排列输出多项式，将一元多项式输入并存储在内存中，能够完成两个多项式的加减运算并输出结果。三、概要设计3.1 存储结构一元多项式的表示在计算机内可以用链表来表示，为了节省存储空间，只存储多项式中系数非零的项。链表中的每一个结点存放多项式的一个系数非零项，它包含三个域，分别存...
多项式计算器 java_链表一元多项式计算器的实现(Java语言描述)
weixin_33470084的博客
02-12 287
链表的经典应用，程序在多项式相加同类项合并还有小的瑕疵，有待改进。代码如下：package 一元多项式计算器;public class PolyNode {private double a;private int i;PolyNode next;public PolyNode(double a,int i){this.a=a;this.i=i;this.next=null;}public Poly...
java 一元多项式的输出_链表一元多项式计算器的实现(Java语言描述)
weixin_42510962的博客
02-24 197
链表的经典应用，程序在多项式相加同类项合并还有小的瑕疵，有待改进。代码如下：package 一元多项式计算器;public class PolyNode {private double a;private int i;PolyNode next;public PolyNode(double a,int i){this.a=a;this.i=i;this.next=null;}public Poly...
大作业 多项式 纯链表实现
Peter_H
04-05 150
之前的多项式本质是数组实现的，而且转换了好几次，受内存空间限制，更难过的是又发现了不能正确算带小数系数的多项式的bug，修了一个小时无果。 在一个月黑风高的夜晚，三千五跑完后偶遇求计学长，一番指点后决定重写。 一个一个读入，边读边判断，重写了一下排序函数，现在可以了! //多项式加减乘 //输入格式：x前面为系数，后面为次数 ;不必按次数输入，可打乱，可有空格（会过滤空格） //例如：x5+2x...
顺序结构、动态链表结构下的一元多项式的加法、减法、乘法的实现。.docx
11-05
本文档是关于一元多项式加法、减法和乘法实现的课程设计报告，主要关注在顺序结构和动态链表结构下的实现方法。设计目标是加深对数据结构的理解，尤其是如何选择合适的数据结构来解决问题，并能编写相关算法。设计...
顺序结构动态链表结构下的一元多项式的加法减法乘法的实现.docx
11-05
四、多项式的减法实现 在顺序结构和动态链表结构下，多项式的减法可以实现为： 1. 初始化两个多项式的数组或链表 2. 遍历两个多项式，比较每个项的指数和系数 3. 如果指数相同，相减系数，否则，合并项 4. 输出...
C++链表基于类实现多项式的加法和乘法
12-11
本话题将探讨如何利用链表类来实现多项式的加法和乘法运算。这些操作在数学计算、数值分析以及计算机图形学等领域有广泛的应用。 首先，我们需要创建一个表示多项式的类。这个类通常会包含一个节点类，用于存储...
14_L3缓存友好的数据结构
刘炫320的博客
09-11 641
老鸟：L3缓存是CPU缓存层次结构中的第三层，通常比L1和L2缓存大，但访问速度稍慢。L3缓存友好的数据结构设计旨在最大限度地减少缓存未命中，从而提升性能。菜鸟：那这些数据结构有什么特点呢？老鸟：主要特点是数据局部性好，也就是说，数据在内存中是连续存储的，这样能更好地利用缓存行。我们可以从一个简单的例子开始，比如数组和链表的对比。老鸟：总结一下，L3缓存友好的数据结构通过提升数据局部性来提高性能。常见的有数组、等。它们在大数据处理和高性能计算中非常有用。但在实际应用中，需要权衡性能、可维护性和具体需求。
21_动态规划与数据结构结合
刘炫320的博客
09-11 494
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
浙大数据结构：05-树7 堆中的路径
qq_74924951的博客
09-11 566
int size;}* Heap;int size;} *Heap;return H;int i;for (;for (;x;i < n;int f = 0;i < l;f = 1;return 0;
从头开始嵌入式第三十八天（数据结构 双向链表）
最新发布
qq_64792908的博客
09-11 629
2. 相比单向链表，双向链表在某些操作上更加灵活，比如在删除节点时，可以快速找到前驱节点进行调整，而单向链表需要从头开始遍历才能找到前驱节点。1. 每个节点包含两个指针，分别指向直接前驱节点和直接后继节点。这使得在双向链表中可以双向遍历，既可以向前也可以向后查找节点。1. 插入操作：可以快速确定插入位置的前后节点，进行指针调整，实现高效的插入操作。1. 需要频繁进行前后遍历的场景，如文本编辑器中对字符的双向移动和操作。2. 删除操作：由于能够直接访问前驱节点，删除操作也更加方便快捷。
【Python】数据结构,链表,算法详解
2201_75415080的博客
09-09 1774
自定义代码-模拟链表删除节点查找节点算法入门-排序类的冒泡排序选择排序插入排序快速排序算法入门-查找类的二分查找-递归版二分查找-非递归版分线性结构-树介绍基本概述特点和分类自定义代码-模拟二叉树"""案例: 自定义代码, 模拟链表.​背景:顺序表在存储数据的时候, 需要使用到连续的空间, 如果空间不够, 就会导致扩容失败, 针对于这种情况, 我们可以通过链表实现.链表在内存中存储的时候, 可以不是连续的空间, "有地儿就行", 所以: 增删相对更好操作.​。
一元多项式链表乘法实现
"使用链表实现一元多项式乘法的实习报告" ...总结来说，这个实习报告提供了一个使用链表数据结构解决多项式乘法问题的实例，通过链表的动态特性简化了操作，同时也展示了链表在数学运算中的应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

南游北归

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

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

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

打赏作者

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

抵扣说明：

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

余额充值