精华内容
下载资源
问答
  • 一元稀疏多项式简单计算器的基本功能是: (1) 输入并建立多项式。 (2) 输出多项式 (3) 多项式a和b相加,建立多项式a+b 。 (4) 多项式ab和b相减,建立多项式a-b 。 (5) 计算多项式在x处的值。 (6) 求多项式a的导函数a...
  • 需求分析 问题描述 设计一个一元稀疏多项式简单计算器 . 基本要求 一元稀疏多项式基本功能包括 1) 输入并建立多项式 2) 输出多项式 输出形式为整数序列 n, c1, e1 , c2, e2 , , c n, en 其中 n 是多项式 的项数 ci ...
  • 本文是关于任一元稀疏多项式的求解问题的描述文中使用链式存储结构(带表头结点的单链表)存储一稀疏元多项式实现了多项式的建立多项式的输出...C语言的优点经过分析将用C语言解决一元稀疏多项式的求解问题算法的描述...
  • 设计一个C++模板类Polynomial,其中T给出了系数的类型。类Polynomial应该带有一个私有成员degree,它是多项式的阶数。当然,它还可能包含其他的私有成员。...采用适当的多项式测试一元稀疏多项式简单计算器的基本功能。
  • 一元稀疏多项式计算器(带界面),其中含有了加减乘除,求导,赋值的功能,并能在设定的界面上运行。
  • 课程设计报告 需求分析 问题描述 设计一个一元稀疏多项式简单计算器 . 基本要求 一元稀疏多项式基本功能包括 输入并建立多项式 输出多项式 输出形式为整数序列 n, c1, e1 , c2, e2, ? , cn, en其中 n 是多项式的项数...
  • 使用MFC可视化界面,自定义一个类存储多项式的系数和指数,利用链表动态存储多项式的每一项,可对多项式进行加减
  • 一元稀疏多项式计算器实验报告(c 编写,附源代码)
  • 报告内有源代码,复制即可运行。采用C++语言编写。
  • 一元稀疏多项式计算器 数据结构课程设计,包含实验报告,实验报告内包含E-R图,对数据的分析. 这是个关于数据结构的简单设计! 内容简单!
  • 数据结构课程设计,一元稀疏多项式计算器,有截图、实验报告!超详细!
  • 一元稀疏多项式计算器实习报告[] PAGE PAGE 1 作者 日期 实习报告 题目设计一个一元稀疏多项式计算器 班级: 姓名 学号_完成日期_ 一课程题目 一元稀疏多项式计算器 需求分析 1一元稀疏多项式简单计算器的功能是 1.1 ...
  • XDOJ-一元稀疏多项式计算器

    千次阅读 热门讨论 2020-12-17 11:21:27
    一元稀疏多项式计算器 要变得更强。 这个问题怎么说,一个上午就这么过去了。果然不愧是小白:( 一开始我还想用三个数组,一个存第一个,一个存第二个,再把结果存到另外一个数组里面。 不过很明显,非常麻烦,当给...

    一元稀疏多项式计算器

    要变得更强。
    ————更新————
    下面同学说的问题我改正啦。
    没改之前:
    可以看到多了个负号,是因为在这个结构体里面,第一项就是0,因此会跳过打印多项式对fooo[0]的求解,所以会多一项负号。
    因此我选择用for循环来找到第一项不是0的就可以啦。
    改后:
    在这里插入图片描述
    ——————————
    这个问题怎么说,一个上午就这么过去了。果然不愧是小白:(
    一开始我还想用三个数组,一个存第一个,一个存第二个,再把结果存到另外一个数组里面。
    不过很明显,非常麻烦,当给我把代码码出来时,得到的结果也很离谱。然后……然后我就几乎全部重改了。
    然后缩减至两个数组,将无论加减都放在一个数组里。
    再将结果放进另外一个数组里。
    需要考虑的点:

    1.关于系数为0 ,1,-1
    2.关于幂次为0,1
    3.如果和为0(使用count来计数)
    

    问题描述

    一元 n 次多项式𝑝0𝑋𝑒0 + 𝑝1𝑋𝑒1 + ⋯ + 𝑝𝑖𝑋𝑒𝑖 + ⋯ + 𝑝𝑛𝑋𝑒𝑛
    项数较少时成为一元稀疏多项式, 例如:3 + 6𝑋3 − 2𝑋8 + 12𝑋20是一个一元稀疏多项式。设计一个一元稀疏多项式计算器程
    序完成两个一元稀疏多项式的加减法,输出结果多项式的各项系数和指数。

    输入说明

    输入数据第 1 行为 3 个正整数 n,m,t。
    其中 n 表示第一个多项式的项数,m 表示第二个多项式的项数,t 表示运算类型,0为加法,1 为减法。
    数据的第 2 行包含 2n 个整数,每两 个整数分别表示第一个多项式每一项的系数和指数;第 3 行包含 2m 个整数,每两个整数分 别表示第二个多项式每一项的系数和指数。两个多项式的每项是按照指数递增的形式给出的, 例如对于多项式3 + 6𝑋3 − 2𝑋8 + 12𝑋20,对应的输入为 3 0 6 3 -2 8 12 20。

    输出说明

    运算结果按指数从低到高的顺序在以多项式形式(见输出样例)输出结果,注意系数为负数 时输出减号,系数为 0 时不输出该项,指数为 1
    时不输出指数。

    输入样例

    6 2 0 1 0 1 1 1 2 1 3 1 4 1 5
    -1 3 -1 4

    输出样例

    1+x+x^2 +x^5

    我的代码

    #include<stdio.h>
    typedef struct{
    	struct{
    		int ratio,power;
    	}items;
    }POLYNOMIA;
    
    int main(){
    	POLYNOMIA f[1000],fooo[1000];
    	int n,m,t,i,j,temp1,temp2,ra,po;
    	int count=1,k=0,sum=0;
    	
    	scanf("%d %d %d",&n,&m,&t);//输入数字 
    	//printf("N:%d M:%d T:%d\n",n,m,t);
    	for(i=0;i<n;i++) scanf("%d %d",&f[i].items.ratio,&f[i].items.power);
    	for(j=0;j<m;j++,i++) {
    		scanf("%d %d",&ra,&po);//在输入时就验证是加法还是减法
    		if(t){//t=1是减法
    			f[i].items.ratio=-ra;
    			f[i].items.power=po;	
    		} 
    		else{//加法 
    			f[i].items.ratio=ra;
    			f[i].items.power=po;
    		}
    	}
    	//进行排序
    	for(i=0;i<m+n;i++){ 
    		for(j=0;j<m+n-i-1;j++){
    			if(f[j].items.power>f[j+1].items.power){
    				temp1=f[j].items.power;
    				f[j].items.power=f[j+1].items.power;
    				f[j+1].items.power=temp1;
    				
    				temp2=f[j].items.ratio;
    				f[j].items.ratio=f[j+1].items.ratio;
    				f[j+1].items.ratio=temp2;
    			}
    		}
    	}
    	//进行计算
    	for(i=0;i<m+n;i++){
    		if(f[i].items.power!=f[i+1].items.power){
    			fooo[k].items.power=f[i].items.power;
    			fooo[k].items.ratio=f[i].items.ratio;
    		//	printf("fooo%d:%d %d\n",k,fooo[k].items.ratio,fooo[k].items.power);	
    			k++;
    		}
    		if(f[i].items.power==f[i+1].items.power){
    			f[i+1].items.ratio+=f[i].items.ratio;
    		}		
    	} 
    	//打印多项式 
    	for(i=0;fooo[i].items.ratio==0;i++);
    	if(fooo[i].items.ratio!=0){//由于第一位不带加减号。
    		count=0; 
    		if(fooo[i].items.ratio==1){
    			if(fooo[i].items.power==0)
    				printf("%d",fooo[0].items.ratio);
    			else if(fooo[i].items.power==1) 
    				printf("x");
    			else 
    				printf("x^%d",fooo[i].items.power);
    		}
    		else if(fooo[i].items.ratio==-1){
    			if(fooo[i].items.power==0)
    			printf("%d",fooo[i].items.ratio);
    			else if(fooo[i].items.power==1) 
    			printf("-x");
    			else 
    			printf("-x^%d",fooo[i].items.power);
    		}
    		else{
    			if(fooo[i].items.power==0)
    				printf("%d",fooo[i].items.ratio);
    			else if(fooo[i].items.power==1) 
    				printf("%dx",fooo[i].items.ratio);
    			else 
    				printf("%dx^%d",fooo[i].items.ratio,fooo[i].items.power);
    		}
    	}
    	for(i++;i<k;i++){//对后面的数字进行加减 
    		if(fooo[i].items.ratio>0){//如果系数是大于0的数字
    		count=0;	
    			if(fooo[i].items.ratio==1){// 要特别注意1的情况
    				if(fooo[i].items.power==0) 
    					printf("%d",fooo[i].items.ratio);
    				else if(fooo[i].items.power==1) 
    					printf("+x");
    				else 
    					printf("+x^%d",fooo[i].items.power);
    			}
    			else{
    				
    				if(fooo[i].items.power==0)
    					printf("+%d",fooo[i].items.ratio);
    				else if(fooo[i].items.power==1) 
    					printf("+%dx",fooo[i].items.ratio);
    				else 
    					printf("+%dx^%d",fooo[i].items.ratio,fooo[i].items.power);
    			}
    	}
    		else if(fooo[i].items.ratio==0){
    			count=1;
    			continue;
    		}
    		else{//如果本身是负数,既有符号,就不需要再加上,多余 
    		count=0;
    			if(fooo[i].items.ratio==-1){
    				
    				if(fooo[i].items.power==0)
    					printf("%d",fooo[i].items.ratio);
    				else if(fooo[i].items.power==1) 
    					printf("-x");
    				else 
    					printf("-x^%d",fooo[i].items.power);
    			}
    			else{
    				if(fooo[i].items.power==0)
    					printf("%d",fooo[i].items.ratio);
    				else if(fooo[i].items.power==1) 
    					printf("%dx",fooo[i].items.ratio);
    				else 
    					printf("%dx^%d",fooo[i].items.ratio,fooo[i].items.power);
    			}	
    		}
    	}
    	if(count)printf("0");
    	return 0;
    }
    

    130行太多了太多了——
    对于一个C的基础题,这就像你写1+1;
    写过程用了nnnnnn个方程来解决一样。
    哎呀,就是比喻不大确切。
    不过,要是能够优化,请扣我!!!
    乐意至极,谢谢。

    展开全文
  • 一元稀疏多项式计算器 【问题描述】 设计一个一元稀疏多项式简单计算器。 【基本要求】 一元稀疏多项式简单计算器的基本功能是: (1)输入并建立多项式 ;输入系数为实数,输入指数为整数 (2)输出多项式。输出...

    一元稀疏多项式计算器

    【问题描述】
    设计一个一元稀疏多项式简单计算器。
    【基本要求】
    一元稀疏多项式简单计算器的基本功能是:
    (1)输入并建立多项式 ;输入系数为实数,输入指数为整数
    (2)输出多项式。输出形式为序列:n,c1,e1,c2,e2,…,cn,en,其中n是多项式的项数,ci和ei分别是第i项的系数和指数,序列按指数降序排列;
    (3)多项式a与b相加,建立多项式a+b;
    (4)多项式a与b相减,建立多项式a-b;

    输入描述

    三行数据,前两行为输入多项式,按序列c1,e1,c2,e2,…,cn,en输入,空格分隔数据,
    若输入的多项式为零多项式,则输入只有一个0,
    第三行为操作选择:0为相加,1为相减。计算减法时,第一行的多项式为被减数,第二行的多项式为减数。
    (P.S.多项式的输入不一定是按指数降序或升序的)

    输出描述

    一行数据,为输出多项式,按指数降序序列c1,e1,c2,e2,…,cn,en输出,常数指数为0,系数保留一位小数。
    若计算得到的结果为零多项式,则只输出一个 0.0 。

    样例输入

    1.5 2 2.5 2 3 -1 4.3 1
    1 2 1 1
    0

    样例输出

    5.0 2 5.3 1 3.0 -1

    问题与难点

    1.输入数据的数目不确定,需要用什么方法来读取数据。

    2.用哪种数据结构来储存输入的多项式。

    3.输入数据为无序,如何在读取数据以后对数据进行排序。

    4.一般多项式输入的数据为偶数,但是若为零多项式输入仅为一个零,如何处理含有零多项式的情况。

    问题解决

    1.利用数据末端为换行符的特点来结束读取,利用scanf函数,当读取到换行符的时候结束读取

    2.考虑到进行加减或者乘除运算时需要进行数据的插入删除操作,且输入数据时不知道数据的确切个数,如果运用数组,操作繁琐而且会造成空间浪费或者空间不足等问题,所以用链表来实现

    3.此处对链表进行排序实际上是对链表里面的数据进行排序,所以可以采用类似于数组的方法,即不进行空间的调换,而只是单纯的交换链表节点之间的数据

    4.读取链表的数据的第一个数,判断是否为零,如果为零,便不进行后面的读取建立链表的操作,然后运算的结果直接输出,比如加减法直接输出另外一个多项式,乘法直接输出零

    5.输出时要求在输出多项式的项数,但仅仅一个项数n与后面的节点结构不符,所以单独输出,不放入链表中解决。

    第一阶段代码

    #include <stdio.h>            //零的考虑  输入数据顺序的考虑  输入数据奇偶的考虑
    #include <malloc.h>           //暂时默认输入为指数降序
    #define ERROW 0               //链表不可用指针自增
    
    
    typedef struct Lnode {
    	//定义链表节点
    	float c;
    	int e;
    	struct Lnode* next;
    }Lnode;
    
    
    Lnode *Creat_list();
    //创建多项式链表并返回头指针
    Lnode *addition(Lnode *head1, Lnode *head2);
    //多项式相加
    Lnode *substraction(Lnode *head1, Lnode *head2);
    //多项式相减
    Lnode *List_insert(Lnode *head,Lnode *p);
    //插入节点函数,其中p为指向插入节点的指针,插入位置为尾部
    void List_Traverse(Lnode *head);
    //遍历链表,输出链表(注意链表为空的情况)
    void List_sort();
    
    
    int main() {
    	int judge;
    	Lnode *head1, *head2, *head3;
    	head1 = Creat_list();
    	head2 = Creat_list();
    	scanf("%d", &judge);
    	if (judge == 1) {
    		head3 = addition(head1, head2);
    	}
    	else {
    		head3 = substraction(head1, head2);
    	}
    	List_Traverse(head3);
    }//main
    
    
    Lnode *List_insert(Lnode *header, Lnode *p) {
    	Lnode *rear = NULL;
    	rear = header;
    	
    	if (header == NULL) {
    		header = p;
    		p->next = NULL;
    	}//if
    	if(rear != NULL) {
    		while (1) {
    			if (rear->next == NULL) {
    				break;
    			}//if
    			rear = rear->next;
    		}//while
    		rear->next = p;
    		p->next = NULL;
    	}//if
    	return header;
    
    }//List_insert
    
    
    Lnode *Creat_list(){
    	Lnode *head = NULL;
    	Lnode *p = NULL, *q = NULL;
    
    	if (!(head = (Lnode *)malloc(sizeof(Lnode)))) {
    		//创立头节点
    		return ERROW;
    	 }
    	if (!(q = (Lnode *)malloc(sizeof(Lnode)))) {
    		//创建链表节点
    		return ERROW;
    	}
    	head->next = q;
    	p = q;
    	p->next = NULL;
    
    
    	while (1) {
    		//接收数据建立链表
    		scanf("%f%d", &q->c, &q->e);
    		if (getchar()!='\n') {
    			if (!(q = (Lnode *)malloc(sizeof(Lnode)))) {
    				return ERROW;
    			}
    			p->next = q;
    			p = q;
    			p->next = NULL;
    		}
    		else {
    			break;
    		}//else
    	}//while
    
    	return head;
    }//Creat_list
    
    
    Lnode *addition(Lnode *head1, Lnode *head2) {
    	float c;
    	Lnode *p1 = NULL, *p2 = NULL, *p = NULL, *q = NULL, *head = NULL, *header = NULL;
    	
    	p1 = head1->next;
    	p2 = head2->next;
    	if (!(head = (Lnode *)malloc(sizeof(Lnode)))) {
    		return ERROW;
    	}
    	header = head->next;
    	header = NULL;
    
    	while (p1 != NULL&&p2 != NULL) {
    		if (p1->e > p2->e) {
    			if (!(p = (Lnode *)malloc(sizeof(Lnode)))) {
    				//创建链表节点
    				return ERROW;
    			}//if
    			p->c = p1->c;
    			p->e = p1->e;
    			p1 = p1->next;
    
    			header = List_insert(header, p);
    		}//if
    		else if(p1->e == p2->e){
    			if (!(p = (Lnode *)malloc(sizeof(Lnode)))) {
    				//创建链表节点
    				return ERROW;
    			}
    			p->c = p1->c + p2->c;
    			p->e = p1->e;
    			p1 = p1->next;
    			p2 = p2->next;
    
    			header = List_insert(header, p);
    		}//else if
    		else if (p1->e < p2->e) {
    			if (!(p = (Lnode *)malloc(sizeof(Lnode)))) {
    				//创建链表节点
    				return ERROW;
    			}//if
    			p->c = p2->c;
    			p->e = p2->e;
    			p2 = p2->next;
    
    			header = List_insert(header, p);
    		}//else if
    	}//while
    	while (p1 == NULL) {
    		if (p2 == NULL) {
    			break;
    		}//if
    
    		header = List_insert(header, p2);
    		p2 = p2->next;
    	}//while
    	while (p2 == NULL) {
    		if (p1 == NULL) {
    			break;
    		}//if
    
    		header = List_insert(header, p1);
    		p1 = p1->next;
    	}//while
    
    	return header;
    }//addition
    
    
    Lnode *substraction(Lnode *head1, Lnode *head2) {
    	Lnode *p = head2, *head = NULL;
    
    	while (p != NULL) {
    		p->c = -1 * p->c;
    		p = p->next;
    	}//while
    
    	head = addition(head1, head2);
    
    	return head;
    }//substraction
    
    
    void List_Traverse(Lnode *head) {
    	Lnode *p = head;
    	if (p == NULL) {
    		printf("链表为空");
    	}
    	while (p != NULL) {
    		printf("%f %d ", p->c, p->e);
    		p = p->next;
    	}//while
    }//List_Traverse

    尚未解决的问题:

    1.未对数据进行排序。

    2.未考虑零多项式。

    3.在进行减法操作后可能出现多项式系数为零的情况,此处应该将此节点从多项式中删除。

    改进代码:

    1.排序算法。

    Lnode *List_sort(Lnode *head) {
    	Lnode *header = NULL, *p = NULL, *q = NULL;
    	float temp1;
    	int temp2;
    
    	header = head->next;//跳过头节点,头节点中无数据
    	p = header;
    	q = header;
    
    	while (p != NULL) {
    		while (q != NULL) {
    			if (p->e < q->e) {
    				temp1 = p->c;
    				temp2 = p->e;
    				p->c = q->c;
    				p->e = q->e;
    				q->c = temp1;
    				q->e = temp2;
    			}//if
    			q = q->next;
    		}//while
    		p = p->next;
    	}//while
    
    	return head;
    }//List_sort

    2.对零多项式的考虑

    第一想法是在读取入链表前,先读一个数判断是否为零,可是一个数无法进行二次读取,故行不通。

    可以先读取入链表以后再判断链表的第一个数是否为零。

    Lnode *Creat_list(){
    	Lnode *head = NULL;
    	Lnode *p = NULL, *q = NULL;
    
    	if (!(head = (Lnode *)malloc(sizeof(Lnode)))) {
    		//创立头节点
    		return ERROW;
    	 }
    	if (!(q = (Lnode *)malloc(sizeof(Lnode)))) {
    		//创建链表节点
    		return ERROW;
    	}
    	head->next = q;
    	p = q;
    	p->next = NULL;
    	
    
    
    	while (1) {
    		//接收数据建立链表
    		scanf("%f", &q->c);
    		if (q->c == 0) {
    			q->e = 0;
    			getchar();
    			break;
    		}
    		scanf("%d", &q->e);
    
    		if (getchar()!='\n') {
    			if (!(q = (Lnode *)malloc(sizeof(Lnode)))) {
    				return ERROW;
    			}
    			p->next = q;
    			p = q;
    			p->next = NULL;
    		}
    		else {
    			break;
    		}//else
    	}//while
    
    	return head;
    }//Creat_list

    此处接受数据的区域本来写的是scanf("%f%d", &q->c, &q->d);

    考虑到输入一个零的时候后者无数据接收,就分开写了。

    3.在进行减法操作后可能出现多项式系数为零的情况,此处应该将此节点从多项式中删除。

    增加一个删除系数为零的节点的函数

    最终代码(如有不足欢迎指正)

    ​
    #include <stdio.h>            //零的考虑  输入数据顺序的考虑  输入数据奇偶的考虑
    #include <malloc.h>           //暂时默认输入为指数降序
    #define ERROW 0               //链表不可用指针自增
    
    
    typedef struct Lnode {
    	//定义链表节点
    	float c;
    	int e;
    	struct Lnode* next;
    }Lnode;
    
    
    Lnode *Creat_list();
    //创建多项式链表并返回头指针
    Lnode *addition(Lnode *head1, Lnode *head2);
    //多项式相加
    Lnode *substraction(Lnode *head1, Lnode *head2);
    //多项式相减
    Lnode *List_insert(Lnode *head,Lnode *p);
    //插入节点函数,其中p为指向插入节点的指针,插入位置为尾部
    void List_Traverse(Lnode *head);
    //遍历链表,输出链表(注意链表为空的情况)
    Lnode *List_sort(Lnode *head);
    //排序算法,对链表进行排序
    Lnode *List_delete(Lnode *head);
    //删除链表中系数为零的节点
    
    
    int main() {
    	int judge;
    	Lnode *head1, *head2, *head3;
    
    	//判断是否有零多项式
    
    	head1 = Creat_list();
    	head1 = List_sort(head1);
    
    	head2 = Creat_list();
    	head2 = List_sort(head2);
    
    	scanf("%d", &judge);
    	if (judge == 1) {
    		head3 = addition(head1, head2);
    	}
    	else {
    		head3 = substraction(head1, head2);
    	}
    	
    	head3 = List_delete(head3);
    	
    	if (head3->next == NULL) {
    		printf("0.0");
    	}
    	else {
    		List_Traverse(head3);
    	}
    }//main
    
    
    Lnode *List_insert(Lnode *header, Lnode *p) {
    	Lnode *rear = NULL;
    	rear = header;
    	
    	if (header == NULL) {
    		header = p;
    		p->next = NULL;
    	}//if
    	if(rear != NULL) {
    		while (1) {
    			if (rear->next == NULL) {
    				break;
    			}//if
    			rear = rear->next;
    		}//while
    		rear->next = p;
    		p->next = NULL;
    	}//if
    	return header;
    
    }//List_insert
    
    
    Lnode *Creat_list(){
    	Lnode *head = NULL;
    	Lnode *p = NULL, *q = NULL;
    
    	if (!(head = (Lnode *)malloc(sizeof(Lnode)))) {
    		//创立头节点
    		return ERROW;
    	 }
    	if (!(q = (Lnode *)malloc(sizeof(Lnode)))) {
    		//创建链表节点
    		return ERROW;
    	}
    	head->next = q;
    	p = q;
    	p->next = NULL;
    	
    
    
    	while (1) {
    		//接收数据建立链表
    		scanf("%f", &q->c);
    		if (q->c == 0) {
    			q->e = 0;
    			getchar();
    			break;
    		}
    		scanf("%d", &q->e);
    
    
    		if (getchar()!='\n') {
    			if (!(q = (Lnode *)malloc(sizeof(Lnode)))) {
    				return ERROW;
    			}
    			p->next = q;
    			p = q;
    			p->next = NULL;
    		}
    		else {
    			break;
    		}//else
    	}//while
    
    	return head;
    }//Creat_list
    
    
    Lnode *addition(Lnode *head1, Lnode *head2) {
    	float c;
    	Lnode *p1 = NULL, *p2 = NULL, *p = NULL, *q = NULL, *head = NULL, *header = NULL;
    	
    	p1 = head1->next;
    	p2 = head2->next;
    	if (!(head = (Lnode *)malloc(sizeof(Lnode)))) {
    		return ERROW;
    	}
    	header = head->next;
    	header = NULL;
    
    	while (p1 != NULL&&p2 != NULL) {
    		if (p1->e > p2->e) {
    			if (!(p = (Lnode *)malloc(sizeof(Lnode)))) {
    				//创建链表节点
    				return ERROW;
    			}//if
    			p->c = p1->c;
    			p->e = p1->e;
    			p1 = p1->next;
    
    			header = List_insert(header, p);
    		}//if
    		else if(p1->e == p2->e){
    			if (!(p = (Lnode *)malloc(sizeof(Lnode)))) {
    				//创建链表节点
    				return ERROW;
    			}
    			p->c = p1->c + p2->c;
    			p->e = p1->e;
    			p1 = p1->next;
    			p2 = p2->next;
    
    			header = List_insert(header, p);
    		}//else if
    		else if (p1->e < p2->e) {
    			if (!(p = (Lnode *)malloc(sizeof(Lnode)))) {
    				//创建链表节点
    				return ERROW;
    			}//if
    			p->c = p2->c;
    			p->e = p2->e;
    			p2 = p2->next;
    
    			header = List_insert(header, p);
    		}//else if
    	}//while
    	while (p1 == NULL) {
    		if (p2 == NULL) {
    			break;
    		}//if
    
    		header = List_insert(header, p2);
    		p2 = p2->next;
    	}//while
    	while (p2 == NULL) {
    		if (p1 == NULL) {
    			break;
    		}//if
    
    		header = List_insert(header, p1);
    		p1 = p1->next;
    	}//while
    
    	return header;
    }//addition
    
    
    Lnode *substraction(Lnode *head1, Lnode *head2) {
    	Lnode *p = head2, *head = NULL;
    
    	while (p != NULL) {
    		p->c = -1 * p->c;
    		p = p->next;
    	}//while
    
    	head = addition(head1, head2);
    
    	return head;
    }//substraction
    
    
    void List_Traverse(Lnode *head) {
    	Lnode *p = head;
    	if (p == NULL) {
    		printf("链表为空");
    	}
    	while (p != NULL) {
    		printf("%f %d ", p->c, p->e);
    		p = p->next;
    	}//while
    }//List_Traverse
    
    
    Lnode *List_sort(Lnode *head) {
    	Lnode *header = NULL, *p = NULL, *q = NULL;
    	float temp1;
    	int temp2;
    
    	header = head->next;//跳过头节点,头节点中无数据
    	p = header;
    	q = header;
    
    	while (p != NULL) {
    		while (q != NULL) {
    			if (p->e < q->e) {
    				temp1 = p->c;
    				temp2 = p->e;
    				p->c = q->c;
    				p->e = q->e;
    				q->c = temp1;
    				q->e = temp2;
    			}//if
    			q = q->next;
    		}//while
    		p = p->next;
    	}//while
    
    	return head;
    }//List_sort
    
    
    Lnode *List_delete(Lnode *head) {
    	Lnode *p =NULL, *q = NULL;
    	p = head;
    	q = p->next;
    	while (q != NULL) {
    		if (q->c == 0) {
    			p->next = q->next;
    			free(q);
    			q = p->next;
    		}//if
    		else {
    			q = q->next;
    			p = p->next;
    		}//else
    	}//whlie
    
    	return head;
    }
    
    ​

    展开全文
  • 一元稀疏多项式计算器 问题描述 设计一个一元稀疏多项式简单计算器。 基本要求 (1)输入并建立多项式。 (2)输出多项式,输出形式为整数序列:n,c1,e1,c2,e2,…,cn,en,其中n是多项式的项数,ci,ei分别是第i 项的...

    一元稀疏多项式计算器


    问题描述

    设计一个一元稀疏多项式简单计算器。

    基本要求

    (1)输入并建立多项式。

    2)输出多项式,输出形式为整数序列:n,c1,e1,c2,e2,…,cn,en,其中n是多项式的项数,ci,ei分别是第i 项的系数和指数,序列按指数降序排列。

    (3)实现多项式a和b相加,建立多项式a+b。

    (4)实现多项式a和b相减,建立多项式a-b。

    (5)计算多项式在x处的值。

    (6)计算器的仿真界面。

    测试数据

    在这里插入图片描述

    带界面版

    博客地址: 一元稀疏多项式计算器仿真界面版

    相关代码

    不带界面,只包含数据结构的设计。

    #define _CRT_SECURE_NO_WARNINGS   
    #include<stdio.h>
    #include<stdlib.h>
    #include<malloc.h>
    #include<string.h>
    typedef struct Polynomial //多项式
    {
    	float coef; //系数
    	int expn;   //指数
    	struct Polynomial *next;//指针
    } Polynomial, *Polyn;
    //创建一个头指针为head,项数为m的一元多项式
    Polyn CreatPolyn(Polyn head, int m)
    {
    	head = (Polyn)malloc(sizeof(struct Polynomial));
    	head->next = NULL;
    	for (int i = 1; i <= m; i++)
    	{
    		Polyn p = (Polyn)malloc(sizeof(struct Polynomial));
    		printf("请输入第%d项的系数与指数:", i);
    		scanf("%f%d", &p->coef, &p->expn);
    		if (p->coef == 0) free(p);
    		else
    		{
    			Polyn q1, q2;
    			q1 = head;
    			q2 = head->next;
    			while (q2 != NULL && p->expn < q2->expn)
    			{
    				q1 = q2;
    				q2 = q2->next;
    			}
    			if (q2 != NULL && p->expn == q2->expn)
    			{
    				q2->coef += p->coef;
    				if (q2->coef == 0)
    				{
    					q1->next = q2->next;
    					free(q2);
    				}
    				free(p);
    			}
    			else
    			{
    				p->next = q2;
    				q1->next = p;
    			}
    		}
    	}
    	return head;
    }
    void printPoLlyn(Polyn head)
    {
    	Polyn q = head->next;
    	int flag = 0;     //记录是否为第一项
    	if (!q)
    	{
    		puts("0");
    		puts("\n");
    		return;
    	}
    	while (q)
    	{
    		if (q->coef > 0 && flag == 1)
    		{
    			printf("+");
    		}
    		flag = 1;
    		if (q->coef != 1 && q->coef != -1)
    		{
    			printf("%g", q->coef);
    
    			if (q->expn == 1) printf("x");
    			else if (q->expn!=0) printf("x^%d", q->expn);
    		}
    		else
    		{
    			if (q->coef == 1)
    			{
    				if (q->expn == 0) printf("1");
    				else if (q->expn == 1) printf("x");
    				else printf("x^%d", q->expn);
    			}
    			if (q->coef == -1)
    			{
    				if (q->expn == 0) printf("-1");
    				else if (q->expn == 1) printf("-x");
    				else printf("-x^%d", q->expn);
    			}
    		}
    		q = q->next;
    	}
    	printf("\n");
    }
    int compare(Polyn a, Polyn b)//比较两个多项式的大小
    {
    	if (a&&b)  // 多项式a和b均不为空
    	{
    		if (a->expn > b->expn) return 1;// a的指数大于b的指数
    		else if (a->expn < b->expn) return -1;
    		else return 0;
    	}
    	else if (!a&&b) return -1; //a为空,b不为空
    	else if (a&&!b) return 1;  //b为空,a不为空 
    	else if (!a&&!b)return 0;  //a,b均为空
    }
    Polyn addPolyn(Polyn a, Polyn b)  //求解a+b,并返回头结点head
    {
    	Polyn head ,qc;
    	Polyn qa = a->next;
    	Polyn qb = b->next;
    	Polyn hc=(Polyn)malloc(sizeof(Polynomial));
    	hc->next = NULL;
    	head = hc;
    	while (qa || qb)
    	{
    		qc= (Polyn)malloc(sizeof(Polynomial));
    		if (compare(qa, qb) == 1)
    		{
    			qc->coef = qa->coef;
    			qc->expn = qa->expn;
    			qa = qa->next;
    		}
    		else if (compare(qa, qb) == 0) //指数相同,直接相加
    		{
    			qc->coef = qa->coef + qb->coef;
    			qc->expn = qa->expn ; 
    			qa = qa->next;
    			qb = qb->next;
    		}
    		else
    		{
    			qc->coef = qb->coef;
    			qc->expn = qb->expn;
    			qb = qb->next;
    		}
             
    		if (qc->coef != 0) //将该节点插入链表中
    		{
    			qc->next = hc->next;
    			hc->next = qc;
    			hc = qc;
    		}
    		else free(qc);		
    	}
    	return head;
    }
    Polyn subPolyn(Polyn a, Polyn b)
    {
    	Polyn h = b;
    	Polyn p = b->next;
    	while(p)
    	{
    		p->coef *= -1;
    		p = p->next;
    	}
    	Polyn head = addPolyn(a, h);
    	for (Polyn i = h->next; i != 0; i = i->next)
    	{ 
    		i->coef *= -1;
    	}		
    	return  head;
    }
    double value(Polyn head, int x) //计算x的值
    {
    	double sum = 0;
    	for (Polyn p = head->next; p != 0; p = p->next)
    	{
    		int tmp = 1;
    		int expn = p->expn;
    		while(expn != 0) //指数不为0
    		{
    			if (expn < 0)   tmp /= x, expn++;
    			else if(expn>0) tmp *= x, expn--;
    		}
    		sum += p->coef*tmp;
    	}	
    	return sum;
    }
    int main()
    {
    	int m;
    	Polyn a = 0, b = 0;
    	printf("请输入a的项数:");
    	scanf("%d", &m);
    	a = CreatPolyn(a, m);
    	printPoLlyn(a);
    	printf("请输入b的项数:");
    	scanf("%d", &m);
    	b = CreatPolyn(b, m);
    	printPoLlyn(b);
    	printf("输出 a+b:");
    	printPoLlyn(addPolyn(a, b));
    	printf("输出 a-b:");
    	printPoLlyn(subPolyn(a, b));
    	printf("请输入x的值:");
    	int x;
    	scanf("%d", &x);
    	printf("输出a的多项式的值为:%.2lf", value(a,x));
    	return 0;
    }
    /*
    测试数据:
    3
    2 1
    5 8
    -3.1 11
    3
    7 0
    -5 8
    11 9
    1
    */
    

    设计详解

    1、一元稀疏多项式的建立

    结构体的定义

    typedef struct Polynomial   //多项式
    {
    	float coef;  //系数
    	int expn;   //指数
    	struct Polynomial *next;//指针
    } Polynomial, *Polyn;
    

    使用带头结点的单链表存贮多项式,插入查找和删除较为方便。数据域中存贮系数和指数,指针域指向下一个节点的位置。
    在这里插入图片描述
    如果所示的存贮结构:
    在这里插入图片描述

    设计思想:

    首先确定好多项式的项数m,新建立一个节点p,用来存贮读入的系数coef和项数expn。然后再定义两个指针q1q2,一前一后,分别指向多项式的两个相邻节点。为了实现多项式的降序排列,这里我们利用插入排序的思想,如果pq2的指数相同,即p->expn == q2->expn,则进行两个节点的合并。如果p的指数小于q2的指数,即p->expn < q2->expn,继续后移两个指针。否则,p的指数小于q1的指数,大于q2的指数,我们找到了插入的位置,将p节点插入两个节点中。执行m次插入操作,就将一元稀疏多项式的建立好了。最后注意要将系数coef==0的节点释放。

    定义两个指针:
    在这里插入图片描述

    找到了插入位置,将节点p插入
    在这里插入图片描述

    代码

    //创建一个头指针为head,项数为m的一元稀疏多项式
    void CreatPolyn(Polyn head, int m)
    {
    	for (int i = 1; i <= m; i++)
    	{
    		Polyn p = (Polyn)malloc(sizeof(struct Polynomial)); //新建节点p
    		printf("请输入第%d项的系数与指数:", i);
    		scanf("%f%d", &p->coef, &p->expn);
    		if (p->coef == 0) free(p);  //将系数为0的节点释放
    		else
    		{
    			Polyn q1, q2;     //两个指针一前一后
    			q1 = head;
    			q2 = head->next;
    			while (q2 != NULL && p->expn < q2->expn)  //p的指数小于q2的指数
    			{
    				q1 = q2;   //继续后移两个指针
    				q2 = q2->next;
    			}
    			if (q2 != NULL && p->expn == q2->expn)   //将相同指数的项进行合并
    			{
    				q2->coef += p->coef;   //合并两项
    				if (q2->coef == 0)
    				{
    					q1->next = q2->next;
    					free(q2);  //将系数为0的节点释放
    				}
    				free(p);   //将节点p释放
    			}
    			else
    			{
    				p->next = q2;    //将节点p插入到q1和q2之间
    				q1->next = p;
    			}
    		}
    	}
    }
    

    2.一元稀疏多项式的加法和减法运算

    设计思想:

    关于多项式的加法运算。首先要定义一个比较函数compare,来比较两个多项式的每项指数大小。

    我们从头到尾处理两个多项式的每一项。如果两项中,多项式a的项的指数大于多项式b的项的指数,那么将a的此项直接作为多项式c的一项。如果多项式a的指数等于多项式b的指数,将两项合并作为多项式c的一项。如果多项式a的指数小于多项式b的指数,那么将b的此项直接作为多项式c的一项。

    因为多项式a和多项b的都是按照指数降序建立的,因此,指数大的项会被先计算出来,使用尾插法插入多项式c中,这样多项式c也是按照指数降序排列的。而减法就是将a-b改为a+(-b)。我们将b的每一项系数都取相反数,最后按照加法计算。

    图示过程:
    在这里插入图片描述
    c = a+b
    将计算出来的qc节点使用尾插法插入多项式c中,然后再将hc=qchc指针后移一位,指向新插入的节点qc
    在这里插入图片描述

    使用尾插法,qc是最后一个包含数据域的节点,因此hc->next==NULL。多项式c仍按照指数降序排列。

    代码

    int compare(Polyn a, Polyn b)//比较两个多项式每项的大小
    {
    	if (a&&b)  // 多项式a和b均不为空
    	{
    		if (a->expn > b->expn) return 1; // a的指数大于b的指数,返回1
    		else if (a->expn < b->expn) return -1; //a的指数小于b的指数,返回-1
    		else return 0; //a的指数等于b的指数,返回0
    	}
    	else if (!a&&b) return -1; //a为空,b不为空
    	else if (a&&!b) return 1;  //b为空,a不为空 
    	else if (!a&&!b)return 0;  //a,b均为空
    }
    //一元稀疏多项式的加法和减法运算
    Polyn addPolyn(Polyn a, Polyn b)    
    	Polyn head ,qc;
    	Polyn qa = a->next;
    	Polyn qb = b->next;
    	Polyn hc=(Polyn)malloc(sizeof(Polynomial));  //新建节点 hc
    	hc->next = NULL;
    	head = hc;  //头结点head指向 hc
    	while (qa || qb)
    	{
    		qc= (Polyn)malloc(sizeof(Polynomial));  //用来存贮计算出来的多项式c的每一项
    		if (compare(qa, qb) == 1)     //多项式a的项的指数大于多项式b的项的指数
    		{
    			qc->coef = qa->coef;      //a的该项直接作为c的一项
    			qc->expn = qa->expn;
    			qa = qa->next;
    		}
    		else if (compare(qa, qb) == 0) //指数相同,两项相加作为c的一项
    		{
    			qc->coef = qa->coef + qb->coef;
    			qc->expn = qa->expn ; 
    			qa = qa->next;
    			qb = qb->next;
    		}
    		else     //多项式a的项的指数小于多项式b的项的指数          
    		{
    			qc->coef = qb->coef;  //b的该项直接作为c的一项
    			qc->expn = qb->expn;
    			qb = qb->next;
    		}
             
    		if (qc->coef != 0)  //将qc节点插入链表中
    		{
    			qc->next = hc->next;
    			hc->next = qc;
    			hc = qc;      //hc后移一位,指向新插入的节点qc
    		}
    		else free(qc);		
    	}
    	return head;
    }
    Polyn subPolyn(Polyn a, Polyn b)  //多项式减法运算
    {
    	Polyn h = b;
    	Polyn p = b->next;
    	while(p)     //将b的每一项系数都取相反数
    	{
    		p->coef *= -1;  
    		p = p->next;
    	}
    	Polyn head = addPolyn(a, h);  //计算 a + (-b)
    	for (Polyn i = h->next; i != 0; i = i->next)  //最后再将b的每项系数还原
    	{ 
    		i->coef *= -1;
    	}		
    	return  head;
    }	
    

    3.一元稀疏多项式的打印和计算在x处的值

    打印输出

    按照这种格式 5x^8-3.1x^11+2x 进行打印输出。从头到尾遍历多项式,特殊处理系数为1-1。系数为1时,输出'x',为-1时,输出'-x',为其他时输出x^,或者 -x^。然后在'x'的后边将每项的指数格式输出。通过对系数和指数的情况分类讨论,正确输出+号和-号。具体思路见代码。

    在这里插入图片描述

    代码

    void printPoLlyn(Polyn head)
    {
    	Polyn q = head->next;
    	int flag = 0;     //记录是否为第一项
    	if (!q)
    	{
    		puts("NULL(0)\t");
    		return;
    	}
    	while (q)  //coef是系数,expn是指数
    	{
    		if (q->coef > 0 && flag == 1)  //系数为正,且不为第一项
    		{
    			printf("+"); //输出加号
    		}
    		flag = 1;
    		if (q->coef != 1 && q->coef != -1) //系数不为-1或者1
    		{
    			printf("%g", q->coef); //输出系数
    
    			if (q->expn == 1) printf("x");  //指数为1,输出x
    			else if (q->expn != 0) printf("x^%d", q->expn);
    		}
    		else
    		{
    			if (q->coef == 1)  //系数为1
    			{
    				if (q->expn == 0) printf("1");  //指数为0,按照常数1输出
    				else if (q->expn == 1) printf("x"); //指数为1,输出x
    				else printf("x^%d", q->expn);
    			}
    			if (q->coef == -1) //系数为-1
    			{
    				if (q->expn == 0) printf("-1");
    				else if (q->expn == 1) printf("-x");
    				else printf("-x^%d", q->expn);
    			}
    		}
    		q = q->next; //将q指针后移
    	}
    	printf("\t\t");
    }
    

    计算多项式在x的值

    遍历要计算的多项式的每一项,定义一个临时变量tmp。当该项的指数expn不为0时,如果为负数,我们进行tmp /= x, expn++。如果为正数,我们进行tmp *= x, expn--。重复上述操作,直到expn==0时停止。最后将每一项的值累加起来,记录到sum中,执行sum += p->coef*tmp 操作,便得到了多项式在x处的值。
    在这里插入图片描述

    代码

    double value(Polyn head, int x) //计算多项式在x处的值
    {
    	double sum = 0;
    	for (Polyn p = head->next; p != 0; p = p->next) //遍历要计算的多项式
    	{
    		int tmp = 1;  //临时变量 tmp用来存贮计算 x^a 或者 x^-a
    		int expn = p->expn;
    		while(expn != 0)  //如果指数不为0,将一直执行下属操作
    		{
    			if (expn < 0)   tmp /= x, expn++;  //累乘运算
    			else if(expn>0) tmp *= x, expn--;  //累除运算
    		}
    		sum += p->coef*tmp;   //将每一项的值累加起来
    	}	
    	return sum;
    }
    
    展开全文
  • 一元稀疏多项式计算器 问题描述 设计一个一元稀疏多项式简单计算器。 基本要求 (1)输入并建立多项式。 (2)输出多项式,输出形式为整数序列:n,c1,e1,c2,e2,…,cn,en,其中n是多项式的项数,ci,ei分别是第i 项的...

    一元稀疏多项式计算器


    问题描述

    设计一个一元稀疏多项式简单计算器。

    基本要求

    (1)输入并建立多项式。

    2)输出多项式,输出形式为整数序列:n,c1,e1,c2,e2,…,cn,en,其中n是多项式的项数,ci,ei分别是第i 项的系数和指数,序列按指数降序排列。

    (3)实现多项式a和b相加,建立多项式a+b。

    (4)实现多项式a和b相减,建立多项式a-b。

    (5)计算多项式在x处的值。

    (6)计算器的仿真界面。

    测试数据

    在这里插入图片描述
    第一组:
    5x^8-3.1x^11+2x
    11x^9-5x^8+7
    第二组:
    6x^-3-x+4.4x^2-1.2x^9
    -6x^-3+5.4x^2-x^2+7.8x^15
    第三组:
    x+x^3
    -x-x^3
    第四组:
    x+x^2+x^3
    0
    可以直接粘贴运行。

    界面开发

    在这里插入图片描述

    设计思想

    首先使用定义的两个函数get_coef()getNums()将读入的字符串如6x^-3-x+4.4x^2-1.2x^9,进行分割得到每一项的系数和指数,然后将其存入系数数组coefs[]和指数数组expns[]中。

    在建立多项式的过程中,使用系数数组和指数数组进行多项式的建立。 使用C 扩充函数库 conio.h 中声明的一个函数gotoxy(int x, int y),利用它将光标移动到指定位置的功能,进行界面的显示和输出。

    使用system("cls")函数对程序进行清屏操作,利用此函数实现了程序的反复读入和输出。

    界面参考大佬博客:一元稀疏多项式简单计算器 十分感谢。

    内部数据结构代码自己实现,相比于网上的大多相关博客,代码简洁明了。

    内部数据结构代码详解:一元稀疏多项式计算器 【 数据结构课设 】 仿真界面 + 代码详解

    void goto_xy(int x, int y)
    {
    	HANDLE hOut;
    	hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    	COORD pos = { x,y };
    	SetConsoleCursorPosition(hOut, pos);
    }
    void show(Polyn a, Polyn b, Polyn c)
    {
    	goto_xy(0, 0); 	 printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
    	goto_xy(0, 1);   printf("┃            一元稀疏多项式简单计算器             ┃\n");
    	goto_xy(0, 2);   printf("┃━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ┫");
    	goto_xy(0, 3);   printf("┃\n"); goto_xy(50, 3);                     printf("┃\n");
    	goto_xy(0, 4);   printf("┃\n"); goto_xy(50, 4);                     printf("┃\n");
    	goto_xy(0, 5);   printf("┃\n"); goto_xy(50, 5);                     printf("┃\n");
    	goto_xy(0, 6);   printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫");
    	goto_xy(0, 7);   printf("┃★ A :"); goto_xy(7, 7); printPoLlyn(a);  goto_xy(50, 7);  printf("┃");
    	goto_xy(0, 8);   printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫");
    	goto_xy(0, 9);   printf("┃★ B :"); goto_xy(7, 9); printPoLlyn(b);  goto_xy(50, 9);  printf("┃");
    	goto_xy(0, 10);  printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫");
    	goto_xy(0, 11);  printf("┃★ C :"); goto_xy(7, 11); printPoLlyn(c);  goto_xy(50, 11);  printf("┃");
    	goto_xy(0, 12);  printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━┫");
    	goto_xy(0, 13);  printf("┃   按7进行多项式相加     ┃   按8进行多项式相减   ┃\n");
    	goto_xy(0, 14);  printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━━━━┫");
    	goto_xy(0, 15);  printf("┃   按0进行多项式输入     ┃   按enter执行确定换行 ┃\n");
    	goto_xy(0, 16);  printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━━━━┫");
    	goto_xy(0, 17);  printf("┃   按1计算多项式A的值    ┃   按2计算多项式B的值  ┃\n");
    	goto_xy(0, 18);  printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━━━━┫");
    	goto_xy(0, 19);  printf("┃   按3计算多项式C的值    ┃   按t退出多项式计算器 ┃\n");
    	goto_xy(0, 20);  printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━━━┫");
    	goto_xy(0, 21);  printf("┃                                                 ┃\n");
    	goto_xy(0, 22);  printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛");
    	goto_xy(1, 23);  printf("【 一元稀疏多项式简单计算器】");
    	goto_xy(2, 3);
    }
    

    代码

    #define _CRT_SECURE_NO_WARNINGS   
    #include<stdio.h>
    #include<stdlib.h>
    #include<malloc.h>
    #include<string.h>
    #include <conio.h>
    #include <windows.h>
    double coefs[80];  //存系数 
    int expns[80];  //存指数 
    int cnt, m;
    double get_coef(char *str)  //在输入的字符串中提取系数
    {
    	double s = 0.0;
    	double d = 10.0;
    	bool flag = false;
    	while (*str == ' ')  str++;
    	if (*str == '-')//记录数字正负  
    	{
    		flag = true;  str++;
    		if (*str == 'x') 	return -1.0;
    	}
    	else if ((*str == '+'&&*(str + 1) == 'x') || (*str == 'x')) return 1.0;
    	if (*str == '+' && (*(str + 1) >= '0'&&*(str + 1) <= '9'))str++;
    	if (!(*str >= '0'&&*str <= '9'))     return s; //如果一开始非数字则退出,返回0.0     
    	while (*str >= '0'&&*str <= '9'&&*str != '.')//计算小数点前整数部分  
    	{
    		s = s * 10.0 + *str - '0';
    		str++;
    	}
    	if (*str == '.')    str++;         //以后为小数部分      
    	while (*str >= '0'&&*str <= '9')  //计算小数部分  
    	{
    		s = s + (*str - '0') / d;
    		d *= 10.0;
    		str++;
    	}
    	return s * (flag ? -1.0 : 1.0);
    }
    void getNums() //在输入的字符串中提取系数和指数
    {
    	int i = 0;
    	cnt = 0;
    	double coef;
    	int expn;
    	char str[80];
    	scanf("%s", str);
    	while (*(str + i))
    	{
    		coef = get_coef(str + i);
    		if (*(str + i) != 'x') i++;
    		while ((*(str + i) >= '0'&&*(str + i) <= '9') || (*(str + i) == '.'))  	i++;
    		if (*(str + i) == '+' || *(str + i) == '-' || *(str + i) == '\0')            expn = 0;
    		else if (*(str + i) == 'x')
    		{
    			i++;
    			if (*(str + i) == '+' || *(str + i) == '-' || *(str + i) == '\0') expn = 1;
    			else if (*(str + i) == '^')
    			{
    				i++;
    				expn = (int)get_coef(str + i);
    				while ((*(str + i) >= '0'&&*(str + i) <= '9') || (*(str + i) == '.'))i++;
    			}
    		}
    		coefs[cnt] = coef;
    		expns[cnt] = expn;
    		cnt++;
    	}
    }
    typedef struct Polynomial //多项式
    {
    	double coef; //系数
    	int expn;   //指数
    	struct Polynomial *next;//指针
    } Polynomial, *Polyn;
    //创建一个头指针为head,项数为m的一元多项式
    void CreatPolyn(Polyn head, int m)  //建立链表,在插入过程中实现单链表有序
    {
    	for (int i = 0; i < m; i++)
    	{
    		Polyn p = (Polyn)malloc(sizeof(struct Polynomial));
    		p->coef = coefs[i];
    		p->expn = expns[i];
    		if (p->coef == 0) free(p);
    		else
    		{
    			Polyn q1, q2;
    			q1 = head;
    			q2 = head->next;
    			while (q2 != NULL && p->expn < q2->expn)
    			{
    				q1 = q2;
    				q2 = q2->next;
    			}
    			if (q2 != NULL && p->expn == q2->expn)
    			{
    				q2->coef += p->coef;
    				if (q2->coef == 0)
    				{
    					q1->next = q2->next;
    					free(q2);
    				}
    				free(p);
    			}
    			else
    			{
    				p->next = q2;
    				q1->next = p;
    			}
    		}
    	}
    }
    void printPoLlyn(Polyn head) //进行格式化打印输出
    {
    	Polyn q = head->next;
    	int flag = 0;     //记录是否为第一项
    	if (!q)
    	{
    		puts("NULL(0)\t");
    		return;
    	}
    	while (q)
    	{
    		if (q->coef > 0 && flag == 1)
    		{
    			printf("+");
    		}
    		flag = 1;
    		if (q->coef != 1 && q->coef != -1)
    		{
    			printf("%g", q->coef);
    
    			if (q->expn == 1) printf("x");
    			else if (q->expn != 0) printf("x^%d", q->expn);
    		}
    		else
    		{
    			if (q->coef == 1)
    			{
    				if (q->expn == 0) printf("1");
    				else if (q->expn == 1) printf("x");
    				else printf("x^%d", q->expn);
    			}
    			if (q->coef == -1)
    			{
    				if (q->expn == 0) printf("-1");
    				else if (q->expn == 1) printf("-x");
    				else printf("-x^%d", q->expn);
    			}
    		}
    		q = q->next;
    	}
    	printf("\t\t");
    }
    int compare(Polyn a, Polyn b)//比较两个多项式的大小
    {
    	if (a&&b)  // 多项式a和b均不为空
    	{
    		if (a->expn > b->expn) return 1;// a的指数大于b的指数
    		else if (a->expn < b->expn) return -1;
    		else return 0;
    	}
    	else if (!a&&b) return -1; //a为空,b不为空
    	else if (a && !b) return 1;  //b为空,a不为空 
    	else if (!a && !b)return 0;  //a,b均为空
    }
    void clear(Polyn c)
    {
    	Polyn p, q;
    	p = c;
    	while (p->next != NULL)
    	{
    		q = p->next;
    		p->next = q->next;
    		free(q);
    	}
    	c->next = NULL;
    }
    void addPolyn(Polyn a1, Polyn b1, Polyn c1)  //求解a+b
    {
    	Polyn a = a1;
    	Polyn b = b1;
    	Polyn c = c1;
    	clear(c1);
    	Polyn head, qc;
    	Polyn qa = a->next;
    	Polyn qb = b->next;
    	head = c;
    	while (qa || qb)
    	{
    		qc = (Polyn)malloc(sizeof(Polynomial));
    		if (compare(qa, qb) == 1)
    		{
    			qc->coef = qa->coef;
    			qc->expn = qa->expn;
    			qa = qa->next;
    		}
    		else if (compare(qa, qb) == 0) //指数相同,直接相加
    		{
    			qc->coef = qa->coef + qb->coef;
    			qc->expn = qa->expn;
    			qa = qa->next;
    			qb = qb->next;
    		}
    		else
    		{
    			qc->coef = qb->coef;
    			qc->expn = qb->expn;
    			qb = qb->next;
    		}
    
    		if (qc->coef != 0) //将该节点插入链表中
    		{
    			qc->next = c->next;
    			c->next = qc;
    			c = qc;
    		}
    	}
    }
    void subPolyn(Polyn a, Polyn b, Polyn c)// a-b可以用a+b来求解,把b改成-b
    {
    	Polyn h = b;
    	Polyn p = b->next;
    	while (p)
    	{
    		p->coef *= -1;
    		p = p->next;
    	}
    	addPolyn(a, h, c);
    	for (Polyn i = h->next; i != 0; i = i->next)
    	{
    		i->coef *= -1;
    	}
    }
    void goto_xy(int x, int y)
    {
    	HANDLE hOut;
    	hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    	COORD pos = { x,y };
    	SetConsoleCursorPosition(hOut, pos);
    }
    void value(Polyn head, int flag)  //计算x的值
    {
    	goto_xy(2, 3); printf(" x = ");
    	double sum = 0, x;
    	scanf("%lf", &x);
    	for (Polyn p = head->next; p != 0; p = p->next)
    	{
    		double tmp = 1;
    		int expn = p->expn;
    		while (expn != 0) //指数不为0
    		{
    			if (expn < 0)      tmp /= x, expn++;
    			else if (expn > 0) tmp *= x, expn--;
    		}
    		sum += p->coef*tmp;
    	}
    	goto_xy(2, 4);
    	if (flag == 1) printf(" A( %g )的值 = %g", x, sum);
    	if (flag == 2) printf(" B( %g )的值 = %g", x, sum);
    	if (flag == 3) printf(" C( %g )的值 = %g", x, sum);
    }
    void show(Polyn a, Polyn b, Polyn c) //界面实现
    {
    	goto_xy(0, 0); 	 printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
    	goto_xy(0, 1);   printf("┃            一元稀疏多项式简单计算器             ┃\n");
    	goto_xy(0, 2);   printf("┃━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ┫");
    	goto_xy(0, 3);   printf("┃\n"); goto_xy(50, 3);                     printf("┃\n");
    	goto_xy(0, 4);   printf("┃\n"); goto_xy(50, 4);                     printf("┃\n");
    	goto_xy(0, 5);   printf("┃\n"); goto_xy(50, 5);                     printf("┃\n");
    	goto_xy(0, 6);   printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫");
    	goto_xy(0, 7);   printf("┃★ A :"); goto_xy(7, 7); printPoLlyn(a);  goto_xy(50, 7);  printf("┃");
    	goto_xy(0, 8);   printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫");
    	goto_xy(0, 9);   printf("┃★ B :"); goto_xy(7, 9); printPoLlyn(b);  goto_xy(50, 9);  printf("┃");
    	goto_xy(0, 10);  printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫");
    	goto_xy(0, 11);  printf("┃★ C :"); goto_xy(7, 11); printPoLlyn(c);  goto_xy(50, 11);  printf("┃");
    	goto_xy(0, 12);  printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━┫");
    	goto_xy(0, 13);  printf("┃   按7进行多项式相加     ┃   按8进行多项式相减   ┃\n");
    	goto_xy(0, 14);  printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━━━━┫");
    	goto_xy(0, 15);  printf("┃   按0进行多项式输入     ┃   按enter执行确定换行 ┃\n");
    	goto_xy(0, 16);  printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━━━━┫");
    	goto_xy(0, 17);  printf("┃   按1计算多项式A的值    ┃   按2计算多项式B的值  ┃\n");
    	goto_xy(0, 18);  printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━━━━┫");
    	goto_xy(0, 19);  printf("┃   按3计算多项式C的值    ┃   按t退出多项式计算器 ┃\n");
    	goto_xy(0, 20);  printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━━━┫");
    	goto_xy(0, 21);  printf("┃                                                 ┃\n");
    	goto_xy(0, 22);  printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛");
    	goto_xy(1, 23);  printf("【 一元稀疏多项式简单计算器】");
    	goto_xy(2, 3);
    }
    void create(Polyn a1, Polyn b1)
    {
    	Polyn a = a1;
    	Polyn b = b1;
    	clear(a1);
    	clear(b1);
    	goto_xy(2, 3); printf("请输入多项式a :  ");   getNums();
    	m = cnt;
    	CreatPolyn(a, m);
    	goto_xy(2, 4); printf("请输入多项式b :  ");	  getNums();
    	m = cnt;
    	CreatPolyn(b, m);
    }
    int main()
    {
    	Polyn a = (Polyn)malloc(sizeof(struct Polynomial)); a->next = NULL;
    	Polyn b = (Polyn)malloc(sizeof(struct Polynomial)); b->next = NULL;
    	Polyn c = (Polyn)malloc(sizeof(struct Polynomial)); c->next = NULL;
    	system("一元多项式计算器 ");
    	system("mode con cols=52 lines=25");
    	system("color e0");
    	char ch, ch1;
    	while (1)
    	{
    		system("cls");
    		show(a, b, c);
    		ch = _getch();
    		if (ch == '0')
    		{
    			create(a, b);
    		}
    		else if (ch == '7')
    		{
    			addPolyn(a, b, c);
    		}
    		else if (ch == '8')
    		{
    			subPolyn(a, b, c);
    		}
    		else if (ch == 't')
    		{
    			exit(0);
    		}
    		else if (ch == '1')
    		{
    			value(a, 1);
    			ch1 = _getch();
    		}
    		else if (ch == '2')
    		{
    			value(b, 2);
    			ch1 = _getch();
    		}
    		else if (ch == '3')
    		{
    			value(c, 3);
    			ch1 = _getch();
    		}
    	}
    	return 0;
    }
    
    
    
    展开全文
  • 一元稀疏多项式计算器(C语言代码实现)

    千次阅读 多人点赞 2020-11-18 15:29:17
    //一元稀疏多项式计算器 #include<stdio.h> #include<stdlib.h> typedef struct LNode { float coef; //系数 int exp; //指数 struct LNode *next; }LNode, Polynomial; //创建一个多项式 void ...
  • 多项式相乘一元稀疏多项式简单计算器的基本功能是: (1)输入并建立多项式; (2)输出多项式,输出形式为整数序列:n,c1,e1,c2,e2,...,cn,en,其中n是多项式的项数,ci和ei分别是第i项的系数和指数,序列按指数降序...
  • XDOJ 综合编程练习 133题 一元稀疏多项式计算器

    千次阅读 多人点赞 2019-12-09 22:27:31
    XDOJ 综合编程练习 133题 一元稀疏多项式计算器 题目内容 输入样例 6 2 0 1 0 1 1 1 2 1 3 1 4 1 5 -1 3 -1 4 输出样例 1+x+x2+x5 判定规则: 忽略首尾空白 忽略空行 忽略大小写 数据之间只保留一个空白 思路 ...
  • 一元稀疏多项式计算器实验报告 课程名称:数据结构 实验名称: 一元稀疏多项式计算器 学 院:钱学森学院 实 验 日 期 2020年 05 月 08日 姓名:孙昊咸 班级:计试91 学号:2196113485 诚信承诺:我保证本实验...
  • i++; expn = (int)get_coef(str + i); while ((*(str + i) >= '0'&&*(str + i) <= '9') || (*(str + i) == '.'))i++;...typedef struct Polynomial //多项式 { double coef; //系数 in...

空空如也

空空如也

1 2 3 4 5 ... 18
收藏数 342
精华内容 136
关键字:

一元稀疏多项式计算器