一元稀疏多项式计算器
 
要变得更强。
 ————更新————
 下面同学说的问题我改正啦。
 没改之前：
 可以看到多了个负号，是因为在这个结构体里面，第一项就是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）输出多项式。输出形式为序列：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.一元稀疏多项式的加法和减法运算
3.一元稀疏多项式的打印和计算在x处的值
   
  
 

 
问题描述
 
设计一个一元稀疏多项式简单计算器。
 
基本要求
 
（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。然后再定义两个指针q1和q2,一前一后，分别指向多项式的两个相邻节点。为了实现多项式的降序排列，这里我们利用插入排序的思想，如果p和q2的指数相同，即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=qc，hc指针后移一位，指向新插入的节点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 项的系数和指数，序列按指数降序排列。
 
（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;
}