精华内容
下载资源
问答
  • 一元多项式相加实验报告(C语言实现)
  • 南昌航空大学实验报告 课程名称 数据结构 实验名称 实验二 线性表的链式存储结构 班 级 080611 学生姓名 学号 08 指导教师评定 ... 用户可以根据自己的需求分别输入两个一元多项式 并且能够实现输入的一元多项式的 显示
  • c++一元多项式相加源码
  • 对一元多项式能实现输入、输出,以及两个一元多项式相加及结果显示,实现链表的说明、创建以及结点的插入和删除等操作,使用vs2010直接打开就可以
  • 一元多项式相加减 详细的解释 源代码 运行结果
  • 一元多项式相加c实现

    2013-04-18 20:26:47
    c语言实现一元多项式相加,用两种方法实现,数组和链表!
  • 实验报告1.4两个一元多项式相加实验 首先考虑存储结构,多项式中的每一项包括“系数”和“指数”两项,且相加运算可能会改变系数和指数,故应采用链式存储结构。在一个单链表结点中,存储多项式一项的系数和指数。...
  • 两个一元多项式相加的程序——/定义结点 /创建链表 /递增排序 /两个多项式相加 /显示多项式 /主函数
  • 数据结构 一元多项式相加

    千次阅读 2018-03-22 23:21:30
    做一个豁达而努力的自己。相加的部分也就是用一个新的链表存储,,,和单链表尾插的方法差不多,,,也就是分了3种...//一元多项式的存储结构 typedef struct Node { int coe; //系数 int exp; //指数 Node *nex...

    做一个豁达而努力的自己。

    相加的部分也就是用一个新的链表存储,,,和单链表尾插的方法差不多,,,也就是分了3种情况,,,

    代码:

    #include <iostream>
    using namespace std;
    
    //一元多项式的存储结构
    typedef struct Node
    {
        int coe;    //系数
        int exp;    //指数
        Node *next;
    }*polynomial;
    //一元多项式的初始化
    bool InitPoly(polynomial &L)
    {
        L = new Node;
        if(!L)
            return false;
        L->next = NULL;
        return true;
    }
    //一元多项式的创建
    void CreatePoly(polynomial &L, int n)
    {
        polynomial s, r;
        r = L;
        while(n--)
        {
            int i = 1;
            s = new Node;
            cout << "输入第" << i << "项的系数和指数:";
            i++;
            cin >> s->coe;
            cin >> s->exp;
            s->next = NULL;
            r->next = s;
            r = s;
        }
    }
    //一元多项式相加
    polynomial AddPoly(polynomial pa, polynomial pb)
    {
        polynomial s;   //创建和指针
        polynomial r;   //创建尾指针
        s = new Node;   //为和节点创建一个头结点
        s->next = NULL;
        r = s;
        pa = pa->next;  //指向首元结点
        pb = pb->next;
        while(pa && pb)
        {
            if(pa->exp > pb->exp)
            {
                r->next = pb;
                r = pb;
                pb = pb->next;
            }
            else if(pa->exp < pb->exp)
            {
                r->next = pa;
                r = pa;
                pa = pa->next;
            }
            else
            {
                int sum = pa->coe + pb->coe;
                if(0 != sum)
                {
                    pa->coe = pa->coe + pb->coe;
                    r->next = pa;
                    r = pa;
                }
                pa = pa->next;
                pb = pb->next;
            }
        }
        if(NULL != pa)
            r->next = pa;
        if(NULL != pb)
            r->next = pb;
        return s;
    }
    //一元多项式的输出
    void PutPoly(polynomial L)
    {
        polynomial p;
        p = L->next;
        while(p)
        {
            cout << "(" << p->coe << "," << p->exp << ")" << '\t';
            p = p->next;
        }
        cout << endl;
    }
    int main()
    {
        polynomial pa, pb;
        InitPoly(pa);
        InitPoly(pb);
        cout << "输入多项式a的项数:";
        int n;
        cin >> n;
        CreatePoly(pa, n);
        cout << "输入多项式b的项数:";
        cin >> n;
        CreatePoly(pb, n);
        cout << "a+b的多项式为:";
        PutPoly(AddPoly(pa, pb));
        return 0;
    }
    

    展开全文
  • C语言一元多项式相加(链表)

    千次阅读 多人点赞 2020-10-30 21:10:52
    今天写一个关于一元多项式相加的程序,就当是在练习运用一下链表的知识。首先,我们先来分析一波,一元多项式相加,首先要用链表创建两个或多个多项式,每个节点里的数据有两个,系数和指数;其次,如果要实现乱幂...

    今天写一个关于一元多项式相加的程序,就当是在练习运用一下链表的知识。首先,我们先来分析一波,一元多项式相加,首先要用链表创建两个或多个多项式,每个节点里的数据有两个,系数和指数;其次,如果要实现乱幂输入,那么还需要一个排序函数;然后就是多项式相加求和的部分,当指数相等时其系数相加,如果不相等那么就比较大小,依次存入新的链表;最后是输出函数,这个部分也分了很多类型,比如:两式相加为常数(2,4,6)、0、系数为1不显示系数(x,x^4)、指数为1不显示指数(x,2x)等等。

    先来定义结构体变量,和单链表的定义结构体一样,不同的是此时我们的数据变成了两个:系数和指数。所以我们这样定义:

    typedef struct node{//构造结构体变量 
    	
    	int coefficient;//定义一个结构体变量“系数” 
    	
    	int exponent;//定义一个结构体变量“指数”
    	
    	node *next;
    	 
    }node;
    

    然后创建单链表来存储第一个多项式的各项式:

    node *create(){//尾插法创建单链表 
    	
    	node *head,*p,*q;
    	
    	int n;//定义一个整型数据n,用来表示输入的多项式的个数 
    	
    	int i = 0;//定义一个整型数据i=0,用来表示的输入的第几个多项式的系数或指数 
    	
    	head = (node*)malloc(sizeof(node));//给head分配内存空间 
    	
    	head->next = NULL; //先让head为空表 
    	
    	q = head;//让q等于head的头节点 
    	
    	printf("你想要输入多少个多项式的数据:");
    	
        scanf("%d",&n);
    	
    	for(i = 0;i < n;i++){
    		
    		p = (node*)malloc(sizeof(node));//给p分配内存空间 
    		
    		printf("请输入第%d项的系数:",i+1);
    		
    		scanf("%d",&p->coefficient);//输入系数 
    		
    		printf("请输入第%d项的指数:",i+1);
    		
    		scanf("%d",&p->exponent);//输入指数 
    		
    		p->next = q->next;
    		
    		q->next = p;
    		
    		q = q->next; 
    		
    	}
    	
    	return head;
    	
    }
    
    

    输出函数,注意这个函数是将两个多项式相加的和已经求出来了进行输出,是把没必要的省略(比如结果为2x^0输出为2),大家看程序就懂了,我就不废话了。

    void print(node *head){//输出单链表
    	
    	node *p;
    	
    	p = (node*)malloc(sizeof(node));
    	
    	p = head->next;
    
    	while(p->next != NULL){//如果p的后继节点不为空时执行下列语句 
    		
    		if(p->coefficient != 0 && p->exponent == 0){//系数不为0指数为0的情况(常数)
    		
    			printf("%d+",p->coefficient);//所以只输入系数
    		
    		}
           
           else if(p->coefficient == 1 && p->exponent == 1){//系数为1指数为1的情况 
    			
    			printf("x+");
    			
    		}	
    		
    		else if(p->coefficient != 0 && p->exponent == 1){//系数不为0指数为1的情况(x,2x,5x……) 
    		
    			printf("%dx+",p->coefficient);//注意前面%d后的x
    		
    		}
    		
    		else if(p->coefficient == 1 && p->exponent != 0){//系数为1指数不为0的情况(x^2,x^5……) 
    			
    			printf("x^%d+",p->exponent);
    			
    		}
    		
    		else if(p->coefficient == 0){//两个多项式相加的和为0时的情况,不输出 
    			
    			printf(""); 
    			
    		}
    		
    		else if(p->coefficient != 1 && p->exponent != 0){//系数不为1指数不为0的情况(2x^3,3x^2……) 
    			
    			printf("%dx^%d+",p->coefficient,p->exponent);
    			
    		}
    		
    		p = p->next;//让p等于它的后继结点,继续循环
    	}
    
    	if(p->exponent == 0 && p->coefficient != 0){//判断最后一个多项式的类型 (ps:因为上述循环当中我们定义p->next!=NULL时执行,那么当p为最后一个结点时,p->next已经是空了,那么这个时候就会跳出循环,最后一个结点的数据就会不运行出来,所以我们需要另写,如果不想写这么多代码的话让它在循环内输出也很简单,大家可以动脑筋想一想),下列语句同上 
    		
    			printf("%d",p->coefficient);
    		
    		}	
    
            else if(p->coefficient == 1 && p->exponent == 1){//系数为1指数为1的情况 
    			
    			printf("x+");
    			
    		}
    		
    		else if(p->exponent == 1 && p->coefficient != 0){
    		
    			printf("%dx",p->coefficient);
    		
    		}
    		
    		else if(p->coefficient == 1 && p->exponent != 0){
    			
    			printf("x^%d",p->exponent);
    			
    		}
    		
    		else if(p->coefficient == 0){
    			
    			printf("0"); //这条语句和上面不一样,因为这是最后一个多项式的输出,如果最后一个多项式的计算结果为0,那么不这样写就会输出(……+)有一个加号,不美观
    			
    		}
    		
    		else if(p->coefficient != 1 && p->exponent != 0){
    			
    			printf("%dx^%d",p->coefficient,p->exponent);
    			
    		}
    
    }
    

    然后就是排序,注意这个排序是将还未执行求和函数的两个多项式进行升幂排序,然后进行相加。(不是已经求和之后进行升幂排序)

    void paixu(node *head){//将多项式按升幂排序 
    	
    	node *p,*q;
    	
    	int temp,temp1;
    	
    	for(p=head->next;p!=NULL;p=p->next){//运用了两个for循环
    		
    		for(q=p->next;q!=NULL;q=q->next){//q为p的后继结点
    			
    			if(p->exponent > q->exponent){//如果p的指数比q的指数大,也就是前一项的指数比后一个指数大,那么交换它们的指数和系数
    			
    				temp = p->exponent;
    			
    				p->exponent = q->exponent;
    			
    				q->exponent = temp;
    			
    				temp1 = p->coefficient;
    			
    				p->coefficient = q->coefficient;
    			
    				q->coefficient = temp1;
    			
    			}
    		} 
    	}
    } 
    

    最后是多项式相加

    node *add(node *&head1,node *head2){//一元多项式相加 (将一元多项式相加的结果存放在head1中) 
    	
    	node *a,*b,*p;
    	
    	a = head1->next;
    	
    	b = head2->next;
    	
    	p = head1;
    	
    	while(a != NULL && b != NULL){
    		
    		if(a->exponent == b->exponent){
    			
    			a->coefficient = a->coefficient+b->coefficient;
    			
    			p->next = a;
    
    			p = p->next;
    			
    			a = a->next;
    			
    			b = b->next;
    			
    		}
    		
    		else if(a->exponent < b->exponent){
    			
    			p->next = a;
    			
    			p = p->next;
    			
    			a = a->next;
    			
    		}
    		
    		else{
    			
    			p->next = b;
    			
    		    p = p->next;
    		    
    		    b = b->next;
    			
    		}
    		
    	}
    	
    	if(a != NULL){//比较结束之后a或b如果有一个还未空就执行下述语句
    			
    			p->next = a;
    			
    		}
    		
    		else{
    			
    			p->next = b;
    			
    	    }
    	
    	return head1;
    	
    }
    

    最后主函数

    int main(){
    	
    	node *head1,*head2,*h;
    	
    	head1 = create();//创建第一个多项式
    	
    	head2 = create();//创建第二个多项式
    
    	paixu(head1);//将第一个多项式按升幂排序
    	
    	paixu(head2);//同上
    	
    	h = add(head1,head2);//相加
    
    	print(h);//输出
    
        return 0;
    
    }
    

    然后一个多项式相加的代码就完成了,在写博客的过程中突然发现自己相加和输出函数有一些问题,就顺便改正了,不得不说这写博客真的好处多多啊,还有就是输出函数里的分类没有完整,因为有系数为负数的情况,我懒得写了,大家有兴趣的可以写一写,不难的,就是简单的判断语句。

    哦!还缺一个头文件

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

    这就完美了。

    最后奉上一个运行结果
    在这里插入图片描述
    这是vscode的运行结果

    上述程序依次写入Dev-C++和vscode以及vs2019中都可以执行,但如果是vs2019里其scanf要改为scanf_s,因为这是vs2019的编译规则,而且还可能出现警告(取消NULL指针对P的调用),这个问题的解决大家可以看我的第一个博客里有解决方法,这里就不多说了。

    最后,就希望路过的大佬可以给一点建议,还有就是希望和我一样的编程小白可以一起努力!

    展开全文
  • 一元多项式相加

    2015-10-21 21:13:30
    编写一元多项式加法运算程序。要求用线性链表存储一元多项式(参照课本)。该程序有以下几个功能: 1. 多项式求和 输入:输入三个多项式,建立三个多项式链表Pa、Pb、Pc (提示:调用CreatePolyn(polynomial ...
  • 编写一元多项式加法运算程序。要求用线性链表存储一元多项式(参照课本)。该程序有以下几个功能: 1. 多项式求和 输入:输入三个多项式,建立三个多项式链表Pa、Pb、Pc (提示:调用CreatePolyn(polynomial &P,int ...
  • JAVA一元多项式相加

    2010-04-20 21:19:26
    用JAVA来实现数据结构的一元多项式相加
  • C++链表实现一元多项式相加代码如下: (输入多项式按次数从高到低排列) #include <iostream> #include <stdio.h> using namespace std; int main() { struct node{ int coe; int order; struct ...

    C++链表实现一元多项式相加代码如下:
    (输入多项式按次数从高到低排列)

    #include <iostream>
    #include <stdio.h>
    
    using namespace std;
    
    int main()
    {
        struct node{
            int coe;
            int order;
            struct node *link;
        };//定义节点类型,coe表示x前的系数,order表示x的次数
    
        int coe,order;
        int i;
    
        int nodeNumA;//多项式A的项数
        printf("请输入多项式A的项数:\n");
        scanf("%d",&nodeNumA);
    
        printf("请输入多项式A:\n");
        struct node *headA=0,*pA=0,*qA=0;
        scanf("%d %d",&coe,&order);
        headA=new struct node;
        headA->coe=coe;
        headA->order=order;
        headA->link=0;
        qA=headA;
        for(i=1;i<nodeNumA;i++){
            scanf("%d %d",&coe,&order);
            pA=new struct node;
            pA->coe=coe;
            pA->order=order;
            pA->link=0;
            qA->link=pA;
            qA=qA->link;
        }//扫入A
    
        printf("\n您输入的多项式A为:\n");
        printf("%dx^%d",headA->coe,headA->order);
        pA=headA->link;
        while(pA!=0){
            printf("+%dx^%d",pA->coe,pA->order);
            pA=pA->link;
        }//输出所输入的多项式A
        printf("\n\n");
    
        int nodeNumB;//多项式B的项数
        printf("请输入多项式B的项数:\n");
        scanf("%d",&nodeNumB);
    
        printf("请输入多项式B:\n");
        struct node *headB=0,*pB=0,*qB=0;
        scanf("%d %d",&coe,&order);
        headB=new struct node;
        headB->coe=coe;
        headB->order=order;
        headB->link=0;
        qB=headB;
        for(i=1;i<nodeNumB;i++){
            scanf("%d %d",&coe,&order);
            pB=new struct node;
            pB->coe=coe;
            pB->order=order;
            pB->link=0;
            qB->link=pB;
            qB=qB->link;
        }//扫入B
    
        printf("\n您输入的多项式B为:\n");
        printf("%dx^%d",headB->coe,headB->order);
        pB=headB->link;
        while(pB!=0){
            printf("+%dx^%d",pB->coe,pB->order);
            pB=pB->link;
        }//输出所输入的多项式B
        printf("\n\n");
        
        struct node *p=0,*q=0;
        p=headA;
        q=headB;
        struct node *headC=0,*r=0,*s=0;
        headC=new struct node;
        while(p->order==q->order&&p->coe+q->coe==0){
            p=p->link;
            q=q->link;
        }//当多项式A、B最高项次数相同且系数和为0直接舍去
        if(p->order==q->order){
            headC->coe=p->coe+q->coe;
            headC->order=p->order;
            headC->link=0;
            s=headC;
            p=p->link;
            q=q->link;
        }
        else if(p->order>q->order){
            headC->coe=p->coe;
            headC->order=p->order;
            headC->link=0;
            s=headC;
            p=p->link;
        }
        else{
            headC->coe=q->coe;
            headC->order=q->order;
            headC->link=0;
            s=headC;
            q=q->link;
        }//此处生成输出的头结点
        while(p!=0&&q!=0){
            r=new struct node;
            while(p->order==q->order&&p->coe+q->coe==0){
                p=p->link;
                q=q->link;
            }//当多项式A、B未扫入C剩下的最高项次数相同且系数和为0直接舍去
            if(p->order==q->order){
                r->coe=p->coe+q->coe;
                r->order=p->order;
                r->link=0;
                s->link=r;
                s=s->link;
                p=p->link;
                q=q->link;
            }
            else if(p->order>q->order){
                r->coe=p->coe;
                r->order=p->order;
                r->link=0;
                s->link=r;
                s=s->link;
                p=p->link;
            }
            else{
                r->coe=q->coe;
                r->order=q->order;
                r->link=0;
                s->link=r;
                s=s->link;
                q=q->link;
            }
        }
        if(p==0&&q!=0)
            s->link=q;
        else if(p!=0&&q==0)
            s->link=p;
    
        printf("\n相加结果为:\n");
        printf("%dx^%d",headC->coe,headC->order);
        r=headC->link;
        while(r!=0){
            printf("+%dx^%d",r->coe,r->order);
            r=r->link;
        }
        printf("\n");
    
        while(headA!=0){
            p=headA;
            headA=headA->link;
            delete p;
        }
        while(headB!=0){
            q=headB;
            headB=headB->link;
            delete q;
        }
        while(headC!=0){
            r=headC;
            headC=headC->link;
            delete r;
        }//释放节点空间
    
        return 0;
    }
    

    在这里插入图片描述

    展开全文
  • 使用单链表实现一元多项式相加
  • 将两个一元多项式相加 问题描述:要求用链表表示一元多项式,并实现算法求两个多项式的和。 #include <iostream> using namespace std; struct polyNode { double coef; // 表示底数 int exp; // 表示...

    将两个一元多项式相加

    问题描述:要求用链表表示一元多项式,并实现算法求两个多项式的和。

    #include <iostream>
    
    using namespace std;
    
    struct polyNode
    {
        double coef;    // 表示底数
        int exp;    // 表示指数
        polyNode* next;
    };
    
    polyNode* createPoly();
    void dispPoly(polyNode*);
    polyNode* addPoly(polyNode*, polyNode*);
    
    int main()
    {
        polyNode* a{createPoly()}, *b{createPoly()}, *c;
    
        cout << "a = ";
        dispPoly(a);
        cout << "b = ";
        dispPoly(b);
        c = addPoly(a, b);
        cout << "c = a + b = ";
        dispPoly(c);
    
        return 0;
    }
    
    polyNode* createPoly()
    {
        polyNode* p{nullptr};
        cout << "创建多项式(当底数和指数同时为0时结束):";
        for (polyNode* q{p}, *r; ; q = r) {
            r = new polyNode;
            cin >> r->coef >> r->exp;
            r->next = nullptr;
            if (!(r->coef) && !(r->exp)) {  // 若底数和指数同时为0,则返回p
                return p;
            }
            if (!p) {   // 若头节点指针未赋值
                p = r;  // 则令头节点指针指向当前新节点
            } else {    // 若头节点指针已赋值
                q->next = r;    // 则将新节点接入表尾
            }
        }
    }
    
    void dispPoly(polyNode* h)
    {
        for (polyNode* p{h}; p; p = p->next) {
            if (p->exp) {   // 若指数不为0
                cout << p->coef << "^" << p->exp;
                cout << " + ";
            } else {    // 若指数为0,则不打印指数部分
                cout << p->coef;
            }
        }
        cout << endl;
    }
    
    polyNode* addPoly(polyNode* a, polyNode* b)
    {
        polyNode* c{nullptr},* p{c};
        for (polyNode* r; a && b; ) {
            r = new polyNode;
            if (a->exp == b->exp) { // 若a数据域的指数等于b的指数
                r->coef = a->coef + b->coef;    // 新节点的数据域的底数等于a的底数与b的底数之和
                r->exp = a->exp;
                a = a->next;    // a和b都指向各自的下一个节点
                b = b->next;
            } else if(a->exp > b->exp) {    // 若a数据域的指数大于b的指数
                r->coef = a->coef;  // 新节点的数据域的底数等于a的底数
                r->exp = a->exp;
                a = a->next;    // a指向a链表的下一个节点
            } else {    // 若a数据域的指数大于b的指数
                r->coef = b->coef;  // 新节点的数据域的底数等于b的底数
                r->exp = b->exp;
                b = b->next;    // a指向a链表的下一个节点
            }
            if (!c) {
                c = r;
            } else {
                p->next = r;
            }
            p = r;
        }
        for (polyNode* r; a; a = a->next) { // 若推出循环后b到达链表末尾而a未到达
            r = new polyNode{a->coef, a->exp, a->next};
            p->next = r;
            p = r;
        }
        for (polyNode* r; b; b = b->next) { // 若推出循环后a到达链表末尾而b未到达
            r = new polyNode{b->coef, b->exp, b->next};
            p->next = r;
            p = r;
        }
        return c;
    }
    
    展开全文
  • 数据结构 study 6:一元多项式相加 一元多项式的表示及相加 // c2-6.h 抽象数据类型Polynomial的实现(见图245) typedef struct // 项的表示,多项式的项作为LinkList的数据元素 { float coef; // 系数 int expn; //...
  • 一元多项式相加可实现代码(c语言) 《数据结构》(C语言版)书上是伪代码,经过不断修改调试,写下可实现的C语言源代码。 创建文件,分为两部分:头文件(Poly.h)和源文件(Poly.c) 一、实验目的 1、了解一元多项式...
  • 两个一元多项式相加

    2020-08-20 19:39:07
    解决方法:建立两条链表,分别存储初始的两个多项式,将第二条多项式的各项插到第一条中,一个多项式有系数和指数,先比较指数,把指数小的插到指数大的前面,若指数相同将系数相加。 #include&amp;amp;amp;lt;...
  • C语言一元多项式相加(链表)含升幂排序

    千次阅读 多人点赞 2020-11-08 12:43:57
    [关于C语言数据结构一元多项式的加法的链表实现]本人初学者,如有错误,感谢各位大佬的指正 本周要完成一项实验内容,C语言链表实现一元多项式的加法,权当是练习一下链表的知识吧。那么首先来思考一个问题。一元...
  • 本程序是一个控制台程序,用户可以根据自己的需求分别输入两个一元多项式,并且能够实现显示输入的一元多项式,再将这两个一元多项式相加,输出结果。 输入的需求是按照指数从小到大进行输入,并且项数必须为正...
  • 文章目录输入输出一元多项式的规则多项式中某项的结点结构生成多项式对多项式进行相加输出多项式释放空间主函数 输入输出一元多项式的规则 输入时按顺序输入一元多项式的系数、指数;输入系数和指数都为0时,表述...
  • 结合书上实验指导书上的例子,采用链式存储结构,将两个线性链表表示的一元多项式相加,并输出。此一元多项式遵循多项式相加运算规则:对于两个一元多项式中存在指数相同的项时,其对应系数相加。合并后系数和为零时...
  • 这是我们学校的一个课程设计题,我是用链表实现的,并且测试类也写得较简单。如果有什么不对的地方,请多指教。
  • 用户根据自己的需求输入两个一元多项式,要求能够显示输入的一元多项式,再将这两个一元多项式相加,输出结果。 二、代码实现 #include<iostream> #include<cstring> #include<malloc.h> #include...
  • 一元多项式相加 还是要用到有序表的合并。 (1)结点的定义 typedef struct LNode { int zhishu; int xishu; struct LNode* next; }LNode, *LinkList;//LinkList为指向结构体LNode的指针类型 结点类型变成两个数据...
  • 由于多项式的加减肯定会用到链表,所以本题运用链表来实现,其中会用到链表的插入,删除以及一些细节的地方,同时为了处理好一些其他的输入问题,或者是不是按照顺序的输入,加入了一些自己的理解,关于链表的知识点...
  • 【问题描述】编写一个程序实现两个一元多项式相加的运算。 【输入形式】从标准输入中读入两行以空格分隔的整数,每一行代表一个多项式,且该多项式中各项的系数均为0或正整数,最高幂次不超过1000000。对于多项式...
  • 用两个链表组织两个一元多项式,将相加的结果保存在前一个链表中。 输入 m(项数) c1(第一项系数) e1(第一项指数) c2 e2 ....... cm(第m项系数) em(第m项指数) n(项数) c1(第一项系数) e1(第一项指数) c2 e2 ....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,364
精华内容 1,345
关键字:

一元多项式相加