精华内容
下载资源
问答
  • 顺序表实现多项式相加

    千次阅读 2019-10-30 14:06:39
    数据结构——顺序表 #include <stdio.h> #include <stdlib.h> /** =====================存储结构定义 开始====.../*顺序表中元素的类型,描述多项式中每一项的系数和指数*/ typedef struct _Elem { in...

    数据结构学习之路——顺序表

    本文思路参考:https://blog.csdn.net/seu_nuaa_zc/article/details/73136455

    题目如下:

    #include <stdio.h>
    #include <stdlib.h>
    /** =====================存储结构定义 开始======================= */
    #define MAX_SIZE 128
    /*顺序表中元素的类型,描述多项式中每一项的系数和指数*/
    typedef struct _Elem
    {
      int coe;  /*系数*/
      int exp;  /*指数*/
    } Elem;
    typedef struct _SeqMult
    {
      Elem data[MAX_SIZE];
      int last;
    } SeqMult;
    void sm_init(SeqMult *ptr_sm);/*插入成功返回1,插入失败返回0;*/
    void sm_create(SeqMult *ptr_sm);
    void sm_print(SeqMult *ptr_sm);
    void sm_add(SeqMult *ptr_sm1, SeqMult *ptr_sm2, SeqMult *ptr_res);
    /****************
     * 多项式相加
     * @param ptr_sm1 第一个多项式
     * @param ptr_sm2 第二个多项式
     * @param ptr_res 相加结果
     ****************************************/
    int main()
    {
      SeqMult sm1, sm2, sm_res, *ptr_sm1, *ptr_sm2, *ptr_res;
      
      ptr_sm1 = &sm1;
      ptr_sm2 = &sm2;
      ptr_res = &sm_res;
      
      /*初始化空*/
      sm_init(ptr_sm1);
      sm_init(ptr_sm2);
      sm_init(ptr_res);
      
      sm_create(ptr_sm1);/*创建第一个多项式*/
      sm_print(ptr_sm1); 
      
      sm_create(ptr_sm2);/*创建第二个多项式*/
      sm_print(ptr_sm2);/*输出第二个多项式*/
      
      sm_add(ptr_sm1,ptr_sm2, ptr_res);/*相加*/
      sm_print(ptr_res);/*输出结果*/
    
      return(0);
     }
    void sm_init(SeqMult *ptr_sm)
    {
      ptr_sm->last = -1;
    }
    int sm_insert(SeqMult *ptr_sm, int coe, int exp)
    {
      /*填写代码,完成多项式插入功能*/
      /*
      注意:
      1. ptr_sm指向当前的多项式顺序表
      2. 当前多项式顺序表按照每一项的的指数递增有序。
      3. 插入后,当前的多项式顺序表依然按照指数递增有序
      */
    }
    void sm_create(SeqMult *ptr_sm)
    {
      int count, i;
      int coe, exp;
      int ok;
      
      scanf("%d", &count);
      ok = 1;
      for(i=0; i<count; i++) 
      {
        scanf("%d(%d)", &coe, &exp);
        ok = sm_insert(ptr_sm, coe, exp);
        if(!ok) {
          break;
        }
      }  
    }
    void sm_print(SeqMult *ptr_sm)
    {
      int i;
      
      for(i=0; i<=ptr_sm->last; i++) {
        if(i != 0) {
          if(ptr_sm->data[i].coe > 0) {
            printf(" + ");
          }
          else if(ptr_sm->data[i].coe < 0) {
            printf(" - "); 
          }
          printf("%d*X^%d", abs(ptr_sm->data[i].coe), ptr_sm->data[i].exp);
        }
        else {
          printf("%d*X^%d", ptr_sm->data[i].coe, ptr_sm->data[i].exp);
        }
      }
      printf("\n");
    }
    void sm_add(SeqMult *ptr_sm1, SeqMult *ptr_sm2, SeqMult *ptr_res)
    {
      /*填写代码,完成多项式相加功能*/
      /*
      注意:
      1. ptr_sm1,ptr_sm2分别指向相加的两个多项式顺序表
      2. ptr_res指向的多项式顺序表将被清空,相加的结果存储到ptr_res指向的顺序表中。
      3. ptr_sm1,ptr_sm2多项式都按照指数递增有序
      */
    }
    

    已知大致函数结构,补齐插入函数和多项式相加函数。
    思路如下 :
    1、插入后,首先有一个排序过程为题目要求,按照指数大小排序,这里我们采用简单的顺序表插入方法+冒泡排序实现。

    int sm_insert(SeqMult *ptr_sm, int coe, int exp)
    {
    	 Elem tmp;
    	 int i, j;
    	 if (ptr_sm->last == MAX_SIZE - 1)
    	 {
    	 	 return 0;
    	 }
     	 ptr_sm->last++;
    	 ptr_sm->data[ptr_sm->last].coe = coe;
     	 ptr_sm->data[ptr_sm->last].exp = exp;
    	 for (i = 1; i<=ptr_sm->last; i++)
     	 {
     		 tmp = ptr_sm->data[i];
      		 j = i - 1;
     		 while (j >= 0 && ptr_sm->data[j].exp > tmp.exp)
      		{
       			ptr_sm->data[j + 1] = ptr_sm->data[j];
       			j--;
      		}
      		ptr_sm->data[j + 1] = tmp;
     	}
     	return 1;
    }
    

    2、进行多项式相加时,先逐个判断相同项,当有相同项时,进行相加。
    3、若无出现相同项,则放到最后进行处理。

    void sm_add(SeqMult *ptr_sm1, SeqMult *ptr_sm2, SeqMult *ptr_res)
    {
    	int i = 0, j = 0, k = 0;
     	float c;
     	while (i < ptr_sm1->last + 1 && j < ptr_sm2->last + 1)
     	{
      		if (ptr_sm1->data[i].exp < ptr_sm2->data[j].exp)
      		{
    			ptr_res->data[k].exp = ptr_sm1->data[i].exp;
    			ptr_res->data[k].coe = ptr_sm1->data[i].coe;
    			i++;
    			k++;
    		}
      		else if (ptr_sm1->data[i].exp > ptr_sm2->data[j].exp)
        		{
    			ptr_res->data[k].exp = ptr_sm2->data[j].exp;
    			ptr_res->data[k].coe = ptr_sm2->data[j].coe;
    			j++;	
    			k++;
       		}
        		else      
        		{
    			c = ptr_sm1->data[i].coe + ptr_sm2->data[j].coe;
       			if (c != 0)
       			{
    				ptr_res->data[k].exp = ptr_sm1->data[i].exp;
    				ptr_res->data[k].coe = c;
    				k++;
      			}
    			i++;
    			j++;
     		}
     	}
    	while (i < ptr_sm1->last+1 )
     	{
    		ptr_res->data[k].exp = ptr_sm1->data[i].exp;
      		ptr_res->data[k].coe = ptr_sm1->data[i].coe;
      		i++; 
      		k++;
    	}
    	while (j < ptr_sm2->last+1 )
    	{
    		ptr_res->data[k].exp = ptr_sm2->data[j].exp;
    		ptr_res->data[k].coe = ptr_sm2->data[j].coe;
    		j++; 
    		k++;
    	}
    	ptr_res->last = k-1;
    }

    本文只用于记录学习经验。
    代码从华为云复制到这里的过程中可能出现问题,若有问题,请指出,谢谢。

    展开全文
  • 代码如下: #include #include #define MAXSIZE 10000 struct ... //定义一个新的结构体数组,存放多项式相加之和 while (da )//利用while循环遍历数组,中止条件为其中一个数组遍历完成 { if (D1[da].expn > D2[db].

    代码如下:

    #include<stdio.h>
    #include<stdlib.h>
    #define MAXSIZE 10000
    struct data
    {
    	int coef;//系数
    	int expn;//指数
    };
    void Add(struct data D1[], struct data D2[], int n, int m);
    void Multiply(struct data D1[], struct data D2[], int n, int m);
    int main()
    {
    	struct data D1[MAXSIZE];
    	struct data D2[MAXSIZE];
    	int n, m;
    	scanf("%d\n", &n);
    	for (int i = 0; i < n; i++)
    	{
    		scanf("%d %d\n", &D1[i].coef, &D1[i].expn);
    	}
    	scanf("%d\n", &m);
    	for (int i = 0; i < m; i++)
    	{
    		scanf("%d %d\n", &D2[i].coef, &D2[i].expn);
    	}
    	Add(D1, D2, n, m);
    	Multiply(D1, D2, n, m);
    	return 0;
    }
    void Add(struct data D1[], struct data D2[], int n, int m)//多项式相加
    {
    	int da = 0, db = 0, dc = 0;
    	struct data D3[MAXSIZE]; //定义一个新的结构体数组,存放多项式相加之和
    	while (da < n && db < m)//利用while循环遍历数组,中止条件为其中一个数组遍历完成
    	{
    		if (D1[da].expn > D2[db].
    展开全文
  • JAVA一元多项式相加

    2010-04-20 21:19:26
    用JAVA来实现数据结构的一元多项式相加
  • 厦门大学信息科学与技术学院软件技术基础实验内容
  • 编写一元多项式加法运算程序。要求用线性链表存储一元多项式(参照课本)。该程序有以下几个功能: 1. 多项式求和 输入:输入三个多项式,建立三个多项式链表Pa、Pb、Pc (提示:调用CreatePolyn(polynomial &P,int ...
  • 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的调用),这个问题的解决大家可以看我的第一个博客里有解决方法,这里就不多说了。

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

    展开全文
  • C语言一元多项式相加(链表)含升幂排序

    千次阅读 多人点赞 2020-11-08 12:43:57
    [关于C语言数据结构一元多项式的加法的链表实现]本人初学者,如有错误,感谢各位大佬的指正 本周要完成一项实验内容,C语言链表实现一元多项式的加法,权当是练习一下链表的知识吧。那么首先来思考一个问题。一元...

    [关于C语言数据结构一元多项式的加法的链表实现]本人初学者,如有错误,感谢各位大佬的指正

    本周要完成一项实验内容,C语言链表实现一元多项式的加法,权当是练习一下链表的知识吧。那么首先来思考一个问题。一元多项式包含哪几个数据项,这个问题很简单吧,多项式是有什么组成的呢。毫无疑问,上过初中的都知道由系数和指数构成,那么显然再加上一个指针域的话就是三个数据项。这个时候结构体的作用就凸显出来,定义一个结构体,包含指数系数和指针域,一个结构体表示一个多项式,为一个节点,两个及以上的节点用结构体内部包含的指针链接起来就成为了链表。那么第一步,先来定义一个结构体吧。当然,不要忘了头文件。

    #include<stdio.h>
    #include<stdlib.h> 
    
    typedef struct node
    { 
    	
    	int coef;//系数 
    	
    	int expo;//指数 
    	
    	node *next;//指针 
    	 
    }node;//取别名,node此后就代表一个完整的结构体数据 
    
    

    好了,结构体创建完之后,要怎么办呢?当然创建链表来存储多项式。代码里面有非常详细的注释,此处不再赘述。

    node *create()  //创建单链表存储多项式 
    { 
    	
    	node *head,*p,*q;//定义三个node类型的指针 
    	
    	int m;//定义一个整型数据m,用来表示输入的多项式的个数 
    	
    	head = (node*)malloc(sizeof(node));//给头指针head分配内存空间 
    	
    	head->next = NULL; //head下一个赋值为空,成为空表 
    	
    	q = head;//让q等于head的头节点 
    	
    	printf("你想要输入多项式的项数为:");
    	
        scanf("%d",&m);
    	
    	for(int i = 0;i < m;i++)
    	{
    		
    		p = (node*)malloc(sizeof(node));//给p分配内存空间 
    		
    		printf("请输入第%d项的系数:",i+1);
    		
    		scanf("%d",&p->coef);//输入系数 
    		
    		printf("请输入第%d项的指数:",i+1);
    		
    		scanf("%d",&p->expo);//输入指数 
    		
    		p->next = q->next;
    		
    		q->next = p;
    		
    		q = q->next; 
    		
    	}
    	
    	return head;
    	
    }
    

    当你成功输入一个多项式的时候你能想到还有什么问题吗,当然不会这么简单,多项式的指数系数的值的不同,我们要做不同的处理,尽可能的考虑周全,使代码更具有一般性。博主在这里定义了一个compare函数用来比较不同的系数指数的大小关系,并返回特定值,用switch case语句进行处理,下面来看代码。

    int cmpare(node *p)//比较两项的指数的大小,并返回特定的值。 
    {
    if(p->coef != 0 && p->expo == 0){return 0;}//当输入多项式为常数
    else if(p->coef == 1 && p->expo == 1){return 1;}//系数为1指数为1
    else if(p->coef != 0 && p->expo == 1){return 2;}//系数不为0指数为1
    else if(p->coef == 1 && p->expo != 0){return 3;}//系数为1指数不为0 
    else if(p->coef == 0){return 4;}//两个多项式相加的和为0时
    else if(p->coef != 1 && p->expo != 0){return 5;}//系数不为1指数不为0 
    }
    void print(node *head) //遍历打印单链表
    {
    	
    	node *p;//定义一个node类型的指针 
    	
    	p = (node*)malloc(sizeof(node));//申请空间 
    	
    	p = head->next;
    
    	while(p->next)//循环语句,如果p的后继节点不为空时开始循环 
    	{
    		switch (cmpare(p))//调用函数进行返回值的选择 
    		{
    		case 0:
    		printf("%d+",p->coef);
            case 1:
    		printf("x+");
    		break;
    		case 2:	
    		printf("%dx+",p->coef);
    		break;
    		case 3: 
    		printf("x^%d+",p->expo);
    		break;
    		case 4:
    		printf("");
    		break; 
    		case 5:
    		printf("%dx^%d+",p->coef,p->expo);
    		break;
    		
    		} 
    		p = p->next;
    		/* P从第一个多项式开始输出,此后一直循环,反复进行第一个while判断
    		直至P为最后一个多项式, p->next为空时,条件判断不成立,跳出循环,
    		执行最后一个多项式的输出 
    		*/ 
    	}
    	
    	switch (cmpare(p))//以下是最后一个个多项式的输出,代码同上 
    		{
    		case 0:
    		printf("%d",p->coef);
            case 1:
    		printf("x");
    		break;
    		case 2:	
    		printf("%dx",p->coef);
    		break;
    		case 3: 
    		printf("x^%d",p->expo);
    		break;
    		case 4:
    		printf("0");
    		break; 
    		case 5:
    		printf("%dx^%d",p->coef,p->expo);
    		break;
    		
    		} 
    } 
    

    当然,不止这一种处理方法,循环嵌套完全能实现同样的功能,读者不妨动动脑子,想想看除了这两种还能怎么处理呢。
    此外,人都喜欢有顺序的东西,排列整齐的美感总是让人欲罢不能,多项式也是一样。你写一个多项式是喜欢乱写,还是从低到高写呢。博主本人喜欢从低到高,所以加了一个排序函数,实现升幂排序,当然这不是必须的,懒得弄的也可以不写,影响不大。

    void srot(node *head)//将多项式按指数从小到大排序 
    { 
    	
    	node *p,*q;
    	
    	int temp1,temp2;//中间变量, 
    	
    	for(p=head->next;p!=NULL;p=p->next)//嵌套循环,C语言书133页,忘了就再看看 
    	{
    		
    		for(q=p->next;q!=NULL;q=q->next)
    		{
    			
    			if(p->expo > q->expo)
    			{
    			
    				temp1 = p->expo;
    			
    				p->expo = q->expo;
    			
    				q->expo = temp1;
    			
    				temp2 = p->coef;
    			
    				p->coef = q->coef;
    			
    				q->coef = temp2;
    			
    			}
    		} 
    	}
    } 
    

    最后,多项式相加,这就有点类似与前面学过的两个顺序表的并集,head1和head2相加,把2加入1里面,最后返回head1。

    node *add(node *&head1,node *head2)
    /*一元多项式相加,特别注意head1前面的地址符, 
    两个多项式相加后,存入第一个多项式head1中,所以这个地址符很重要 
    */ 
    { 
    	
    	node *Pa,*Pb,*p;
    	
    	Pa = head1->next;//以下此类代码均需要画图理解指针的指向 
    	
    	Pb = head2->next;//建议对于指针不是很熟悉的,画图看着写 
    	
    	p = head1;
    	
    	while(Pa != NULL && Pb != NULL)
    	{
    		
    		if(Pa->expo == Pb->expo)
    		{
    			
    			Pa->coef = Pa->coef+Pb->coef;
    			
    			p->next = Pa; 
    
    			p = p->next;
    			
    			Pa = Pa->next;
    			
    			Pb = Pb->next;
    			
    		}
    		
    		else if(Pa->expo < Pb->expo)
    		{
    			
    			p->next = Pa;
    			
    			p = p->next;
    			
    			Pa = Pa->next;
    			
    		}
    		
    		else
    		{
    			
    			p->next = Pb;
    			
    		    p = p->next;
    		    
    		    Pb = Pb->next;
    			
    		}
    		
    	}
    	
    	if(Pa != NULL)
    	{
    			
    		p->next = Pa;
    			
    	}
    		
    	else
    	{
    		p->next = Pb;
    			
    	}
    	
    	return head1;
    	
    }
    

    为了让你的电脑更干净,加上一个消除函数吧

    int Destoey(node *head1,node *head2,node *head3)
    {
    	head1=NULL;
    	head2=NULL;
    	head3=NULL;
    	printf("多项式销毁成功!");
    	return 0; 
     }
    

    哈哈,很简单吧,到这里一个简单的多项式相加就已经完成了,对了,还有主函数。

    int main()
    {
    	
    	node *head1,*head2,*sum;
    	
    	head1 = create();
    	printf("你输入的第一个多项式为:");
    	srot(head1); 
    	print(head1);
    	printf("\n");
    	head2 = create();//创建多项式 
        printf("你输入的第二个多项式为:");
    	srot(head2); 
    	print(head2);
    	printf("\n");
    	sum = add(head1,head2);//调用函数进行求和 
    	print(sum);//输出结果
    	printf("\n"); 
    	Destoey(head1,head2,sum);
        return 0;
    
    }
    

    博主这里其实考虑的也不是很周全,系数指数为负该怎么办呢,感兴趣的读者自己去试试吧,今天早上从温暖的被窝起来写这篇帖子,博主好困。最后,附上一个运行结果,快去试试吧。
    在这里插入图片描述
    最后,看着运行结果不知道给位读者有没有发现一个问题,相加函数好像只是把两个多项式中相同的项加了起来,却并没有把一个多项式中的相同项加起来,虽然没什么影响,但毕竟不美观。读者老爷们思考思考该怎么解决这个问题呢。(博主是初学者,代码几乎都是按照初学者最容易理解的方式来呈现,不喜勿喷)

    以上代码依次加入Dev-C++和vs2019编译器中
    均可实现,但是在vs里需要将scanf改为scanf_s,这是vs编译器的规则所定,而且还会出现警告(取消NULL指针对p的调用,可以正常运行)解决方法是在出现警告的代码段旁加入一段代码。

    if(p==NULL){
    printf("内存分配失败!");
    return 0;
    }
    
    展开全文
  • 顺序表实现: #include #include #include #include #include using namespace std; #define maxsize 1000 struct Data { double coef; int exp; }; struct List { Data* elem; int length; }; char s[100]...
  • 数据结构(12)线性表之C++实现一元多项式相加

    万次阅读 多人点赞 2016-03-17 11:24:57
    第二种代码的实现仅链表存储形式实现导言上篇文章,我们说明了一元多项式相加采取了什么形式和抽象定义数据类型定义以及实现一元多项式相加的方法,本节将用具体代码来实现一元多项式相加。一元多项式表现形式...
  • 排序顺序表实现一元多项式加减乘运算 排序顺序表结点类 public class Term implements Comparable<Term> { private double coef; //系数 private int expn; //指数 public Term(double coef, int expn){...
  • 文章目录输入输出一元多项式的规则多项式中某项的结点结构生成多项式对多项式进行相加输出多项式释放空间主函数 输入输出一元多项式的规则 输入时按顺序输入一元多项式的系数、指数;输入系数和指数都为0时,表述...
  • 数据结构经典案例,一元多项式的加法器
  • 利用顺序表实现多项式相加

    千次阅读 2015-09-10 00:21:18
    //利用顺序表实现多项式相加 #include #include #include #include #include using namespace std; const int N=10; struct Data { int xishu;  int zhishu; }; template class SeqList { private:  T
  • 用户根据自己的需求输入两个一元多项式,要求能够显示输入的一元多项式,再将这两个一元多项式相加,输出结果。 二、代码实现 #include<iostream> #include<cstring> #include<malloc.h> #include...
  • 代码比较简单,没有完全按照严蔚敏版《数据结构(C语言版)》上39页到43页上的要求,只是实现了简单功能,且此代码输入多项式时只能按升幂的顺序输入(因为没有写多项式排序的函数) 个人感觉此代码短小精悍,且易...
  • (数据结构)一元多项式相加: 题目说明: 编写一元多项式加法运算程序。要求用线性链表存储一元多项式(参照课本)。该程序有以下几个功能: 多项式求和 输入:输入三个多项式,建立三个多项式链表Pa、Pb、Pc ...
  • } } } void add(Linknode &L1,Linknode L2) //总函数:将L1,L2两个多项式相加, //我未增加一个新链表而是将L2链表合到L1上以减少空间复杂度 //还有一个思路:新建一个链表一次遍历L1,L2:若L1,L2上的指数相同...
  • (( p 1 p_1 p1​, e 1 e_1 e1​), ( p 2 p_2 p2​, e 2 e_2 e2​), ……,( p n p_n pn​, e n e_n en​)) 3 链式存储 /* --------------------------一元多项式相加运算-------------------------- */ /* * 1....
  • 一元多项式相加+相乘(顺序表实现).cpp
  • 【问题描述】编写一个程序实现两个一元多项式相加的运算。 【输入形式】从标准输入中读入两行以空格分隔的整数,每一行代表一个多项式,且该多项式中各项的系数均为0或正整数,最高幂次不超过1000000。对于多项式...
  • 顺序表应用之两个一元多项式求和

    千次阅读 2016-02-18 23:09:00
    #include #include typedef struct node{ int coef; // 系数 int exp ; // 指数 struct node *next ; }NODE; NODE *creatPoly ..."一元多项式相加\n" ) printPoly(result); }
  • 一元多项式相加

    2015-10-21 21:13:30
    编写一元多项式加法运算程序。要求用线性链表存储一元多项式(参照课本)。该程序有以下几个功能: 1. 多项式求和 输入:输入三个多项式,建立三个多项式链表Pa、Pb、Pc (提示:调用CreatePolyn(polynomial ...
  • printf("两个多项式相加后的结果为:\n"); AddPolyn(pa,pb,pc); PrintPolyn(pc,n+m); return 0; } void PrintPolyn(Polylist L,int n) { Polylist p; int i=0; p=L->next; while(p && i) { i++; printf...
  • #define MAXSIZE 10000 // 顺序表的最大长度 typedef struct { // 数据元素定义   char no[20]; // 图书ISBN  char name[50]; // 图书名字  float price; // 图书价格  …… } ElemType; (Book) ...
  • printf("输出两个多项式相加后的结果多项式A:"); return 0; } ![图片说明](https://img-ask.csdn.net/upload/202002/03/1580718627_581287.png) 哪位大神能帮忙看一下代码哪里出问题了吗?运行结果不...
  • 由于多项式的加减肯定会用到链表,所以本题运用链表来实现,其中会用到链表的插入,删除以及一些细节的地方,同时为了处理好一些其他的输入问题,或者是不是按照顺序的输入,加入了一些自己的理解,关于链表的知识点...
  • 编写一元多项式加法运算程序。要求用线性链表存储一元多项式(参照课本)。该程序有以下几个功能: 1. 多项式求和 输入:输入三个多项式,建立三个多项式链表Pa、Pb、Pc (提示:调用CreatePolyn(polynomial &P,int ...
  • //那就让它们相加就好了 } } void Insert ( Node e , Node p ) { p . next = e . next ; e . next = p ; } void Print ( ) { Node p = head . next ; while ( p != null )...
  • 用 C语言实现一元多项式的运算(相加,相减,相乘) 1.创建多项式时,无论指数项按什么顺序输入,输出均能实现以升幂顺序输出,且输入时有相同指数项时能够实现合并。 2.能够代入确切的X计算出最终多项式的值。 ...
  • 一元多项式相加的算法和C++实现

    万次阅读 多人点赞 2015-08-13 15:53:08
    利用顺序表的链式存储实现一元多项式的加法

空空如也

空空如也

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

顺序表一元多项式相加