哈工大数据结构实验1-线性结构及其应用

本文仅供参考，严禁抄袭！

一、实验目的

  通过设计一元多项式计算器深入理解并熟练运用线性结构解决实际问题，在此过程中强化逻辑能力及编程能力。

二、实验要求及实验环境

实验要求

  以动态或者静态链表存储一元多项式，在此基础上按要求完成对一元多项式
的运算。（为保证多项式的值的准确性，多项式的系数可以用分数表示，涉及到
两个分数相除时，结果也可以用分数表示。）

• 能够输入多项式（可以按各项的任意输入顺序，建立按指数降幂排列的多项
  式）和输出多项式（按指数降幂排列）,以文件形式输入和输出，并显示。
• 能够给出计算两个多项式加法、减法、乘法和除法运算的结果多项式，除法
  运算的结果包括商多项式和余数多项式。
• 能够计算一元多项式的 k 阶导函数。
• 能够计算多项式在某一点 x=x0 的值，其中 x0是一个浮点型常量，返回结果为
  浮点数。
• 要求尽量减少乘法和除法运算中间结果的空间占用和结点频繁的分配与回收
  操作。（提示：利用循环链表结构或者可用空间表的思想，把循环链表表示
  的多项式返还给系统或者可用空间表，从而解决上述问题）。

实验环境

Visual Studio 2019

三、设计思想（本程序中的用到的所有数据类型的定义，主程序的流程图及各程序模块之间的调用关系）

逻辑设计

  线性结构

物理设计

  链式存储结构存储多项式信息

数据类型的定义

• 结构体类型(struct Item)： 包括分数的分子(int coeffnume)，分母(int coeffdeno)，指数(int power)，指向下一节点的指针(struct Item *next)；
• Item *Init函数： 表头(Item *head)，p所指节点的前驱(Item *pr)，指向当前节点的指针p(Item *p)，存储多项式的字符数组poly(char poly[])，记录读入系数为正数还是负数的标记变量flag(int flag)，存储运算结果的result(int result);
• Show函数： 指向当前链表节点的指针p(Item *p)；
• GCD函数： a,b分别为两个被求最大公因子的整型数(int a, int b)；
• Reduction函数： 存储两个数的最大公因子的整型数gcd(int gcd)；
• Addfraction\Subtractfraction\Multifraction\Dividefraction函数： 存储第一个分数分子的coeffnume1(int coeffnume1)，存储第一个分数分母的coeffdeno1(int coeffdeno1)存储第二个分数分子的coeffnume2(int coeffnume2)，存储第二个分数分母的coeffdeno2(int coeffdeno2)
• Sort函数： 指向当前节点的指针p(Item *p)，指向当前节点前驱节点的pr(Item *pr)，指向当前最大指数节点的pmax(Item *pmax)，分别作为分子、分母、指数交换变量的tempnume, tempdeno, tempower(int tempnume, tempdeno, tempower)，记录最大指数的maxpower(int maxpower)
• MergeSortedPoly函数： 指向当前节点的指针p(Item *p)，指向当前节点前驱节点的pr(Item *pr)
• ShowFile函数： 指向当前节点的指针p(Item *p)，表头结点head(Item *head)
• ReverseLink函数： 指向当前节点的指针p(Item *p)，指向当前节点前驱节点的pr(Item *pr)，指向当前节点后继节点的指针pp(Item *pp)
• AddPoly函数： 第一个多项式的表头结点head1(Item *head1)，第二个多项式的表头结点head2(Item *head2)，指向当前节点的指针p(Item *p)
• SubPoly函数： 第一个多项式的表头结点head1(Item *head1)，第二个多项式的表头结点head2(Item *head2)，指向当前节点的指针p(Item *p)，指向第二个多项式某节点的pp(Item *pp)
• AddPolyPro\SubPolyPro函数： 第一个多项式的表头结点head1(Item *head1)，第二个多项式的表头结点head2(Item *head2)，指向第一个多项式某节点的指针p1(Item *p1)，指向第二个多项式某节点的p2(Item *p2)
• MultiPoly函数： 第一个多项式的表头结点head1(Item *head1)，第二个多项式的表头结点head2(Item *head2)，指向第一个多项式某节点的指针poly1(Item *poly1)，指向第二个多项式某节点的poly2(Item *poly2)，指向第二个多项式某节点前驱节点的polypr2(Item *polypr2)，指向新建链表当前节点的指针p(Item p)，指向新建链表当前节点前驱节点的指针pr(Item pr)
• DividePoly函数： 第一个多项式的表头结点head1(Item *head1)，第二个多项式的表头结点head2(Item *head2)，指向第一个多项式某节点的指针poly1(Item *poly1)，指向第二个多项式某节点的poly2(Item *poly2)，指向新建链表当前节点的指针p(Item p)，指向新建链表当前节点前驱节点的指针pr(Item pr)，存储除数多项式最高项分子、分母、指数的coeffnume,coeffdeno,power(int coeffnume,int coeffdeno,int power)，记录已做除法次数的count(int count)
• Deviate函数： 表头指针head(Item* head)，指向当前节点指针p(Item *p)，记录求阶数的k(int k)
• Calculate函数： 表头指针head(Item* head)，指向当前节点指针p(Item *p)，记录结果的result(int result),保存指定点数值的x(int x)
• main函数： 保存两个多项式的poly1、poly2(char poly1[],char poly2[])，保存功能序号的fuction(int fuction)，保存乘法结果链表的头指针headMul(Item *headMul)，保存除法结果链表的头指针headDiv(Item *headDiv)

流程图

调用关系

函数Reductioon调用了函数GCD

函数Addfraction\Subtractfraction\Multifraction\Dividefractinon调用了Reduction

函数ShowFile调用了Sort，MergeSortedPoly

函数AddPoly\SubPoly\AddPolyPro\SubPolyPro调用了Sort，MergeSortedPoly

函数MultiPoly调用了Sort，ReverseLink，Multifraction，AddPolyPro

函数DividePoly调用了Sort，Dividefraction，Multifraction，SubPolyPro，Show

函数Deviate\Calculate调用了Sort，MergeSortedPoly

函数main调用了ReadFile，ShowFile，Init，AddPoly，Show，SubPoly，MultiPoly，DividePoly，Deviate，Calculate

源代码

#include<iostream>
#include<stdlib.h>
#include<stdio.h>
#define Maxlength 100
using namespace std;
typedef struct Item
{
	int coeffnume;//系数分数的分子
	int coeffdeno;//系数分数的分母
	int power;//此项的指数
	struct Item* next;
}Item;//创建一个链表节点
void Readfile(char *p1, char *p2)
{
	FILE* fp;
	errno_t err;
	err = fopen_s(&fp, "poly.txt", "r");//打开文件
	if (err!=0)
	{
		cout << "打开失败" << endl;
		exit(0);
	}
	fgets(p1, 100, fp);//读取第一行多项式
	fgets(p2, 100, fp);//读取第二行多项式
	fclose(fp);
	char* find1 = strchr(p1, '\n');  //找出data中的"\n"
	if (find1)
		*find1 = '\0';//将找到的'\n'替换成'\0'
	char* find2 = strchr(p2, '\n');  //找出data中的"\n"
	if (find2)
		*find2 = '\0';//将找到的'\n'替换成'\0'
}
Item* Init( char *poly )//将读入的多项式存至链表中
{
	Item* head = new Item;//创建表头
	Item* pr = head;
	int i = 0, j = 0, result = 0, flag = 0;//flag用来标识当前项的系数是否为负数（1表示负数，0表示正数）
	while (1)
	{
		Item* p = new Item;
		pr->next = p;
		p->next = NULL;
		pr = p;
		//下面是对从文件中读出的多项式字符串进行处理，将其从字符型转化为整数型，存到链表中
		if (poly[i] == '-' || poly[i] == '+')
		{
			if (poly[i] == '-')
			{
				flag = 1;//系数为负数，则置flag为1
			}
			i++;
			if (poly[i] == 'x' && poly[i - 1] == '-')//若当前项为x且前一项为负号，则其系数必为-1
			{
				p->coeffnume = -1;
				p->coeffdeno = 1;
			}
			else if (poly[i] == 'x' && poly[i - 1] == '+')//若当前项为x且前一项为正号，则其系数必为1
			{
				p->coeffnume = 1;
				p->coeffdeno = 1;
			}
			else if (poly[i] >= '0' && poly[i] <= '9')
			{
				j = i;
				while (poly[i] != '/' && poly[i] != 'x' && poly[i] != '\0' && poly[i] != '+' && poly[i] != '-')
				{
					i++;
				}
				result = 0;
				for (; j < i; j++)
				{
					result += int(pow(10, i - j - 1)) * int(poly[j] - '0');//处理大于一位的系数，将其从字符型转换为整型数
				}
				if (flag == 1)//flag为1则将得到的结果加负号
					p->coeffnume = -result;
				else
					p->coeffnume = result;
				flag = 0;
				if (poly[i] == '/')
				{
					i++;
					j = i;
					while (poly[i] != 'x' && poly[i] != '\0' && poly[i] != '+' && poly[i] != '-')
					{
						i++;
					}
					result = 0;
					for (; j < i; j++)
					{
						result += int(pow(10, i - j - 1)) * int(poly[j] - '0');
					}
					p->coeffdeno = result;
				}
				else
				{
					p->coeffdeno = 1;
				}
			}
		}
		else if (poly[i] == 'x')
		{
			p->coeffnume = 1;
			p->coeffdeno = 1;
		}
		else if (poly[i] >= '0' && poly[i] <= '9')
		{
			j = i;
			while (poly[i] != '/' && poly[i] != 'x' && poly[i] != '\0' && poly[i] != '+' && poly[i] != '-')
			{
				i++;
			}
			result = 0;
			for (; j < i; j++)
			{
				result += int(pow(10, i - j - 1)) * int(poly[j] - '0');
			}
			p->coeffnume = result;
			if (poly[i] == '/')
			{
				i++;
				j = i;
				while (poly[i] != 'x' && poly[i] != '\0' && poly[i] != '+' && poly[i] != '-')
				{
					i++;
				}
				result = 0;
				for (; j < i; j++)
				{
					result += int(pow(10, i - j - 1)) * int(poly[j] - '0');
				}
				p->coeffdeno = result;
			}
			else
			{
				p->coeffdeno = 1;
			}
		}
		if (poly[i] == 'x')
		{
			i++;
			if (poly[i] == '^')
			{
				i++;
				j = i;
				while (poly[i] != '+' && poly[i] != '-' && poly[i] != '\0')
				{
					i++;
				}
				result = 0;
				for (; j < i; j++)
				{
					result += int(pow(10, i - j - 1)) * int(poly[j] - '0');
				}
				p->power = result;
			}
			else if (poly[i] == '+' || poly[i] == '-' || poly[i] == '\0')
			{
				p->power = 1;
			}
		}
		else if (poly[i] == '+' || poly[i] == '-' || poly[i] == '\0')
		{
			p->power = 0;
		}
		if (poly[i] == '\0')//若读完字符串，则退出循环
		{
			break;
		}
	}
	return head;
}
void Show(Item* head)
{
	Item* p = head;
	p = p->next;
	while (p != NULL)
	{
		if (p->coeffnume == 0)
		{
			continue;
		}
		else if (p->coeffnume > 0&& p != head->next)
		{
			cout << "+";
		}
		if (p->coeffdeno == 1)
		{
			if (p->coeffnume == 1 && p->power==0)
			{
				cout << p->coeffnume;
		    }
			else if (p->coeffnume == -1 && p->power != 0)
			{
				cout << '-';
			}
			else if (p->coeffnume != 1)
			{
				cout << p->coeffnume;
			}
		}
		if (p->coeffnume != 0 && p->coeffdeno != 1)
		{
			cout << p->coeffnume << "/" << p->coeffdeno;
		}
		if (p->power > 1)
		{
			cout << "x^" << p->power;
		}
		else if (p->power == 1)
		{
			cout << "x";
		}
		p = p->next;
	}
}
int GCD(int a, int b)//辗转相除法，求解两个数的最大公因数，约分时用
{
	if (a % b == 0)
		return b;
	return GCD(b , a % b);
}
void Reduction(int &coeffnum, int &coeffdeno)//引用修改参数，约分分数
{
	int gcd = GCD(coeffnum, coeffdeno);//先求出最大公因数，后分子分母分别除去最大公因数
	coeffnum = coeffnum / gcd;
	coeffdeno = coeffdeno / gcd;
	if (coeffdeno < 0 && coeffnum < 0)
	{
		coeffdeno = -coeffdeno;
		coeffnum = -coeffnum;
	}
	else if (coeffdeno < 0 && coeffnum>0)
	{
		coeffdeno = -coeffdeno;
		coeffnum = -coeffnum;
	}
	else if (coeffdeno == 0)
	{
		cout << "分母为0" << endl;
	}

}
void Addfraction(int coeffnume1,int coeffdeno1,int coeffnume2,int coeffdeno2,int &coeffnume,int &coeffdeno)//两分数相加，引用变量存储加完的结果
{
	coeffnume = coeffnume1 * coeffdeno2 + coeffnume2 * coeffdeno1;
	coeffdeno = coeffdeno1 * coeffdeno2;
	Reduction(coeffnume, coeffdeno);
}
void Subtractfraction(int coeffnume1, int coeffdeno1, int coeffnume2, int coeffdeno2, int& coeffnume, int& coeffdeno)//两分数相减，引用变量存储结果
{
	coeffnume = coeffnume1 * coeffdeno2 - coeffnume2 * coeffdeno1;
	coeffdeno = coeffdeno1 * coeffdeno2;
	Reduction(coeffnume, coeffdeno);
}
void Multifraction(int coeffnume1, int coeffdeno1, int coeffnume2, int coeffdeno2, int& coeffnume, int& coeffdeno)//两分数相乘，引用变量存储结果
{
	Reduction(coeffnume1, coeffdeno2);
	Reduction(coeffnume2, coeffdeno1);
	coeffnume = coeffnume1 * coeffnume2;
	coeffdeno = coeffdeno1 * coeffdeno2;
	Reduction(coeffnume, coeffdeno);
}
void Dividefraction(int coeffnume1, int coeffdeno1, int coeffnume2, int coeffdeno2, int& coeffnume, int& coeffdeno)//两分数相除，引用变量存储结果
{
	if (coeffnume2 == 0)
	{
		cout << "被除数不能为0" << endl;
		exit(0);
	}
	Reduction(coeffnume1, coeffnume2);
	Reduction(coeffdeno2, coeffdeno1);
	coeffnume = coeffnume1 * coeffdeno2;
	coeffdeno = coeffnume2 * coeffdeno1;
	Reduction(coeffnume, coeffdeno);
}
void Sort(Item* head)//给链表排序，按每个节点中存储的此项的指数，降幂排序，采用选择排序算法
{
	Item* pr = head -> next;
	Item* p = head->next->next;
	Item* pmax = pr;
	int tempnume, tempdeno, tempower, maxpower;
	while (pr->next != NULL)
	{
		p = pr->next;
		maxpower = pr->power;
		while (p != NULL)
		{
			if (p->power > maxpower)
			{
				maxpower = p->power;
				pmax = p;
			}
			p = p->next;
		}
		if (pr->power != maxpower)
		{
			tempdeno = pmax->coeffdeno;
			tempnume = pmax->coeffnume;
			tempower = pmax->power;
			pmax->coeffdeno = pr->coeffdeno;
			pmax->coeffnume = pr->coeffnume;
			pmax->power = pr->power;
			pr->coeffdeno = tempdeno;
			pr->coeffnume = tempnume;
			pr->power = tempower;
		}
		pr = pr->next;
	}
}
void MergeSortedPoly(Item* head)//对排序后链表表示的多项式进行合并
{
	Item* pr = head->next;
	Item* p = pr->next;
	while (p != NULL)
	{
		if (p->power == pr->power)
		{
			Addfraction(pr->coeffnume, pr->coeffdeno, p->coeffnume, p->coeffdeno, pr->coeffnume, pr->coeffdeno);//若幂指数相等，则合并
			pr->next = p->next;
			delete p;//删除被合并项原先的内存
			p = pr->next;
		}
		else
		{
			p = p->next;
			pr = pr->next;
		}
	}
	pr = head;
	p = pr->next;
	while (p != NULL)
	{
		if (p->coeffnume == 0)//若此项分子为0，则删除此项
		{
			pr->next = p->next;
			delete p;
			p = pr->next;
		}
		else
		{ 
			pr = p;
			p = p->next;
		}
	}
}
void ShowFile(Item* head)//将读入的多项式合并同类项并降幂排序后写入文件
{
	Sort(head);
	MergeSortedPoly(head);
	FILE* fp = NULL;
	errno_t err;
	err = fopen_s(&fp, "poly.txt", "a");
	if (err != 0)
	{
		cout << "打开失败" << endl;
		exit(0);
	}
	Item* p = head;
	p = p->next;
	//以下是规范写入的格式，即将链表中的内容转换为人类易于理解的形式写入文件
	while (p != NULL)
	{
		if (p->coeffnume == 0)
		{
			continue;
		}
		else if (p->coeffnume > 0 && p != head->next)
		{
			cout << "+";
			fprintf(fp, "+");
		}
		if (p->coeffdeno == 1)
		{
			if (p->coeffnume == 1 && p->power == 0)
			{
				cout << p->coeffnume;
				fprintf(fp, "%d", p->coeffnume);
			}
			else if (p->coeffnume == -1 && p->power != 0)
			{
				cout << '-';
				fprintf(fp, "-");
			}
			else if (p->coeffnume != 1)
			{
				cout << p->coeffnume;
				fprintf(fp, "%d", p->coeffnume);
			}
		}
		if (p->coeffnume != 0 && p->coeffdeno != 1)
		{
			cout << p->coeffnume << "/" << p->coeffdeno;
			fprintf(fp, "%d", p->coeffnume);
			fprintf(fp, "/");
			fprintf(fp, "%d", p->coeffdeno);
		}
		if (p->power > 1)
		{
			cout << "x^" << p->power;
			fprintf(fp, "x^%d", p->power);
		}
		else if (p->power == 1)
		{
			cout << "x";
			fprintf(fp, "x");
		}
		p = p->next;
	}
	fprintf(fp, "\n");
	fclose(fp);
}
void ReverseLink(Item* head)//链表反转
{
	if (head->next != NULL)
	{
		Item* pr = NULL;
		Item* p = head->next;
		Item* pp = NULL;
		while (p != NULL)
		{
			pp = p->next;
			p->next = pr;
			pr = p;
			p = pp;
		}
		head->next = pr;
	}
}
void AddPoly(Item* head1, Item* head2)//多项式相加，结果保存在存储第一个多项式的链表中
{
	Item* p = head1;
	while (p->next != NULL)
	{
		p = p->next;
	}
	p->next = head2->next;
	Sort(head1);
	MergeSortedPoly(head1);//算法思路是将存储第二个的链表接到第一个链表后面，而后合并同类项即可，这种方法的一个弊端是不会留存两个原始多项式
}
void SubPoly(Item* head1, Item* head2)//两多项式相减，结果存储在第一个多项式的链表中
{
	Item* pp = head2->next;
	Item* p = head1;
	while (pp != NULL)
	{
		pp->coeffnume = -pp->coeffnume;
		pp = pp->next;
	}
	while (p->next != NULL)
	{
		p = p->next;
	}
	p->next = head2->next;
	Sort(head1);
	MergeSortedPoly(head1);//算法思路是将存储第二个的链表中每个系数添加负号后接到第一个链表后面，而后合并同类项即可，这种方法的一个弊端是不会留存两个原始多项式
}
void AddPolyPro(Item* head1,Item* head2)//另一种多项式加法的实现，目的是保留第二个多项式，途径是复制第二个多项式链表，将复制后的链表与第一个多项式相连，后合并同类项
{
	Item* p1 = head1;
	Item* p2 = head2->next;
	while (p1->next != NULL)
	{
		p1 = p1->next;
	}
	while (p2 != NULL)
	{
		Item* p = new Item;
		p1->next = p;
		p->next = NULL;
		p->coeffnume = p2->coeffnume;
		p->coeffdeno = p2->coeffdeno;
		p->power = p2->power;
		p1 = p;
		p2 = p2->next;
	}
	Sort(head1);
	MergeSortedPoly(head1);
}
void SubPolyPro(Item* head1, Item* head2)另一种多项式减法的实现，目的是保留第二个多项式，途径是复制第二个多项式链表，将复制后的链表与第一个多项式相连，后合并同类项
{
	Item* p1 = head1;
	Item* p2 = head2->next;
	while (p1->next != NULL)
	{
		p1 = p1->next;
	}
	while (p2 != NULL)
	{
		Item* p = new Item;
		p1->next = p;
		p->next = NULL;
		p->coeffnume = -p2->coeffnume;
		p->coeffdeno = p2->coeffdeno;
		p->power = p2->power;
		p1 = p;
		p2 = p2->next;
	}
	Sort(head1);
	MergeSortedPoly(head1);//合并同类项
}
Item* MultiPoly(Item* head1, Item* head2)//多项式乘法，算法思想是：将第二个多项式升幂排序，用其第一项乘第一个多项式的各项，其结果保存在新开的链表中，而后依此循环，时间复杂度为O(m*n)，m，n分别为第一、二个多项式的项数
{
	Sort(head1);
	Sort(head2);
	ReverseLink(head2);
	Item* head = new Item;//记录和
	Item* poly1 = head1->next;
	Item* poly2 = head2->next;
	Item* polypr2 = head2;
	Item* pr = head;
	int coeffnume,coeffdeno;
	while (poly1 != NULL)
	{
		Item* p = new Item;
		pr->next = p;
		p->coeffdeno = 0;
		p->coeffnume = 0;
		p->power = 0;
		p->next = NULL;
		pr = p;
		poly1 = poly1->next;
	}
	poly1 = head1->next;
	pr = head->next;
	while (poly1 != NULL)
	{
		Multifraction(poly2->coeffnume, poly2->coeffdeno, poly1->coeffnume, poly1->coeffdeno, poly1->coeffnume, poly1->coeffdeno);
		pr->coeffnume += poly1->coeffnume;
		pr->coeffdeno += poly1->coeffdeno;
		pr->power = poly1->power = poly1->power + poly2->power;
		pr = pr->next;
		poly1 = poly1->next;
	}
	polypr2 = poly2;
	poly2 = poly2->next;
	poly1 = head1->next;
	pr = head->next;
	while (poly2 != NULL)
	{
		coeffnume = poly2->coeffnume * polypr2->coeffdeno;
		coeffdeno = poly2->coeffdeno * polypr2->coeffnume;
		while (poly1 != NULL)
		{
			Multifraction(coeffnume, coeffdeno, poly1->coeffnume, poly1->coeffdeno, poly1->coeffnume, poly1->coeffdeno);
			poly1->power = poly1->power + poly2->power - polypr2->power;
			poly1 = poly1->next;
		}
		AddPolyPro(head, head1);
		polypr2 = poly2;
		poly2 = poly2->next;
		poly1 = head1->next;
		pr = head->next;
	}
	return head;
}
Item* DividePoly(Item* head1, Item* head2)
/*多项式除法，算法思想是：用第一个多项式的第一项除以第二个多项式的首项，结果存放到新开的链表中，然后将这个结果与第二个多项式相乘，用第一个多项式减去此结果，
得到的差多项式替换第一个多项式，存放到第一个链表中，依此循环，直至第一个链表中存放的多项式最高项指数小于第二个多项式最高项指数或已经除尽则停止循环，最后第一个链表中存储的是余数多项式，之前新开链表中存放的是商多项式*/
{
	Sort(head1);
	Sort(head2);
	int coeffnume,coeffnume1;
	int coeffdeno,coeffdeno1;
	int power,power1;
	int count = 0;
	if (head1->next->power < head2->next->power)
	{
		cout << "被除数次数低于除数" << endl;
		exit(0);
	}
	Item* head = new Item;
	Item* poly1 = head1->next;
	Item* poly2 = head2->next;
	Item* pr = head;
	coeffnume = poly2->coeffnume;
	coeffdeno = poly2->coeffdeno;
	power = poly2->power;
	while (head1->next!=NULL&& head1->next->power >= power)
	{
		count++;
		Item* p = new Item;
		pr->next = p;
		p->next = NULL;
		Dividefraction(head1->next->coeffnume, head1->next->coeffdeno, coeffnume, coeffdeno, p->coeffnume, p->coeffdeno);
		p->power = poly1->power - power;
		poly2 = head2->next;
		while (poly2 != NULL)
		{
			if (count == 1)
			{
				Multifraction(poly2->coeffnume, poly2->coeffdeno, p->coeffnume, p->coeffdeno, poly2->coeffnume, poly2->coeffdeno);
				poly2->power = poly2->power + p->power;
				poly2 = poly2->next;
			}
			else
			{
				Dividefraction(p->coeffnume, p->coeffdeno, pr->coeffnume, pr->coeffdeno, coeffnume1, coeffdeno1);
				power1 = p->power - pr->power;
				Multifraction(poly2->coeffnume, poly2->coeffdeno, coeffnume1, coeffdeno1, poly2->coeffnume, poly2->coeffdeno);
				poly2->power = poly2->power + power1;
				poly2 = poly2->next;
			}
		}
		SubPolyPro(head1, head2);
		poly1 = head1->next;
		pr = p;
	}
	cout << "余数多项式为：";
	if (head1->next == NULL)
	{
		cout << "0";
	}
	else
	{
		Show(head1);
	}
	cout << endl;
	return head;
}
void Derivate(Item* head)//求导，算法思想：循环求导，每次求一阶
{
	int k;
	Sort(head);
	MergeSortedPoly(head);
	cout << "请输入要求导的阶数：";
	cin >> k;
	Item* p = head->next;
	for (int i = 0; i < k; i++)
	{
		p = head->next;
		while (p != NULL)
		{
			Multifraction(p->coeffnume, p->coeffdeno, p->power, 1, p->coeffnume, p->coeffdeno);
			p->power = p->power - 1;
			p = p->next;
		}
	}
	MergeSortedPoly(head);//合并同类项
}
double Calculate(Item* head)//计算多项式在某一点的值
{
	Sort(head);
	MergeSortedPoly(head);
	Item* p = head->next;
	double result = 0,x;
	cout << "请输入x_0：";
	cin >> x;
	while (p != NULL)
	{
		result += (((p->coeffnume * 0.1) * 10) / p->coeffdeno) * pow(x, p->power);
		p = p->next;
	}
	cout << "计算结果为：";
	return result;
}
int main()
{
	char poly1[Maxlength],poly2[Maxlength];
	Readfile(poly1, poly2);
	Item* head1 = Init(poly1);
	cout << "读入的第一个多项式为：";
	ShowFile(head1);
	cout << endl;
	int fuction;//存储功能序号
	//以下打印指引提示
	cout << "1.加法" << endl << "2.减法" << endl << "3.乘法" << endl << "4.除法" << endl << "5.求导" << endl << "6.求值" << endl;
	cout << "请选择功能序号：";
	cin >> fuction;
	switch (fuction)
	{
		case 1:
		{
			Item* head2 = Init(poly2);
			AddPoly(head1, head2);
			cout << "相加后的结果多项式为：";
			Show(head1);
			break;
		}
		case 2:
		{
			Item* head2 = Init(poly2);
			SubPoly(head1, head2);
			cout << "相减后的结果多项式为：";
			Show(head1);
			break;
		}
		case 3:
		{
			Item* head2 = Init(poly2);
			Item* headMul = MultiPoly(head1, head2);
			cout << "乘积多项式为：";
			Show(headMul);
			break;
		}
		case 4:
		{
			Item* head2 = Init(poly2);
			Item* headDiv = DividePoly(head1, head2);
			cout << "商多项式为：";
			Show(headDiv);
			break;
		}
		case 5:
		{
			Derivate(head1);
			cout << "求导后的多项式为：";
			Show(head1);
			break;
		}
		case 6:
		{
			printf("%lf", Calculate(head1));
			break;
		}
		default:
			break;
	}
	return 0;
}