数据结构实验一

一元多项式实验报告

问题描述

要求程序能够完成如下功能：(1)创建多项式；(2)打印显示多项式；(3)销毁多项式；(4)复制多项式；(5)求两个多项式的和；(6)求两个多项式的差；(7)求两个多项式的积；(8)求一个多项式的n次幂；(9)计算一个多项式在x=a处的值；(10)求两个多项式的商和余式；(11)求两个多项式的最大公约式和最小公倍式；(12)求一个多项式的n阶导函数；(13)求一个多项式的不定积分；(14)求一个多项式在区间[a, b]上的定积分。

程序输入输出是在命令行中完成的。用户选择所需功能，并输入数据进行运算。输入错误数据时会要求重新输入或打印错误信息，但不会终止程序。直到用户选择退出，程序结束。

实验内容

存储结构示意图：

程序中使用的主要数据结构是以链表存储的多项式，其定义为

typedef struct lnode {
	float coef;  // 系数
	int expn;    // 指数
	struct lnode* next;
}lnode, * polynomial;

程序中的主要函数及函数原型为：

void print_menu(void);//打印菜单 
void descend_polyn(polynomial &P);//使多项式降序排列 
void delete_0(polynomial &P);//去掉多项式中系数为零的项 
void merge_polyn(polynomial &P);//合并多项式中的同类项 
void creat_polyn(polynomial &P);//建立一个新的多项式 
void print_polyn(polynomial &P);//打印指定多项式 
void destroy_polyn(polynomial &P);//摧毁指定多项式 
void copy_polyn(polynomial &Pa, polynomial &Pb);//复制一个多项式到指定位置 
void add_polyn(polynomial &Pa, polynomial &Pb);//两个多项式相加，Pa返回结果，Pb摧毁
void minus_polyn(polynomial &Pa, polynomial &Pb);//两个多项式相减，Pa返回结果，Pb摧毁 
void mult_polyn(polynomial &Pa,polynomial &Pb,polynomial &Pc);//两个多项式相乘，结果存入Pc 
void power_polyn(polynomial &Pa,polynomial &Pb,int n);//多项式幂运算，对Pa做幂运算，结果存入Pb 
void calculate_polyn(polynomial &P); //多项式求值，无返回值 
void div_polyn(polynomial &Pa,polynomial &Pb,polynomial &Pc,polynomial &Pd);//Pa除去Pb,将商存入Pc，将余式存入Pd 
void minus_polyn2(polynomial &Pa,polynomial &Pb,polynomial &Pc);//Pa减去Pb，结果存入Pc 
void gcd_polyn(polynomial &Pa,polynomial &Pb,polynomial &Pc);//求Pa和Pb的最大公因式，结果存入Pc 
void diff_polyn(polynomial &P,int k);//多项式求k次导 
void indefinite_integral(polynomial &Pa,polynomial &Pb);//不定积分 
void definite_integral(polynomial &P,float a,float b);//定积分 
double evaluation_polyn(polynomial &P,float k);//多项式在k处的值，有返回值 
int get_order(void);//获得标准位置，返回一个用户要的位置下标 

讨论与结论

• 在打印显示多项式的算法中，开始忘记考虑链表为空表的情况，当计算x^3+x^2+1和x^3+x^2+1的差时，没有输出。后来在打印显示算法中增加了对空表的处理，显示为0；

• 销毁链表中，最后没给头指针赋值NULL，导致出现一系列BUG；

• 采用get_order()函数，使每次获得位置下标时，可以安全、方便的获得0~99的数；

• 有一个清屏并显示所有多项式的功能选项，极大地提升了用户的体验。

• 在开写大作业之前，应先构思好数据结构和一些函数的具体实现，该程序经过借鉴网络的一些代码和个人思考，采用指针数组和三个基本函数（降序排序、合并同类项、去零），大大方便了程序的编写和实现。

• 验证时发现 3x^2与 3的最大公约式为1，经过回看代码，原来是当时觉得最大公约式应把最高项系数置为1而导致的错误。说明代码需要不断测试改进才能加以完善。

完整源代码

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define MAX_TERMS_NUMBER 100
typedef struct lnode {
	float coef;  // 系数
	int expn;    // 指数
	struct lnode* next;
}lnode, * polynomial;

//函数原型 
void print_menu(void);                                                        //打印菜单 
void descend_polyn(polynomial &P);                                            //使多项式降序排列 
void delete_0(polynomial &P);                                                 //去掉多项式中系数为零的项 
void merge_polyn(polynomial &P);                                              //合并多项式中的同类项 
void creat_polyn(polynomial &P);                                              //建立一个新的多项式 
void print_polyn(polynomial &P);                                              //打印指定多项式 
void destroy_polyn(polynomial &P);                                            //摧毁指定多项式 
void copy_polyn(polynomial &Pa, polynomial &Pb);                              //复制一个多项式到指定位置 
void add_polyn(polynomial &Pa, polynomial &Pb);                               //两个多项式相加，Pa返回结果，Pb摧毁
void minus_polyn(polynomial &Pa, polynomial &Pb);                             //两个多项式相减，Pa返回结果，Pb摧毁 
void mult_polyn(polynomial &Pa,polynomial &Pb,polynomial &Pc);                //两个多项式相乘，结果存入Pc 
void power_polyn(polynomial &Pa,polynomial &Pb,int n);                        //多项式幂运算，对Pa做幂运算，结果存入Pb 
void calculate_polyn(polynomial &P);                                          //多项式求值，无返回值 
void div_polyn(polynomial &Pa,polynomial &Pb,polynomial &Pc,polynomial &Pd);  //Pa除去Pb,将商存入Pc，将余式存入Pd 
void minus_polyn2(polynomial &Pa,polynomial &Pb,polynomial &Pc);              //Pa减去Pb，结果存入Pc 
void gcd_polyn(polynomial &Pa,polynomial &Pb,polynomial &Pc);                 //求Pa和Pb的最大公因式，结果存入Pc 
void diff_polyn(polynomial &P,int k);                                         //多项式求k次导 
void indefinite_integral(polynomial &Pa,polynomial &Pb);                      //不定积分 
void definite_integral(polynomial &P,float a,float b);                        //定积分 
double evaluation_polyn(polynomial &P,float k);                               //多项式在k处的值，有返回值 
int get_order(void);                                                          //获得标准位置，返回一个用户要的位置下标 

void print_menu() {
	printf("********说明：本程序使用指针数组存放每个多项式，至多存储100个多项式，请牢记每个多项式的位置下标********\n\n");
	printf("==================================================菜单==================================================\n\n");
	printf("           1.创建多项式                                          2.打印显示多项式\n\n");
	printf("           3.销毁多项式                                          4.复制多项式\n\n");
	printf("           5.求两个多项式的和                                    6.求两个多项式的差\n\n");
	printf("           7.求两个多项式的积                                    8.求一个多项式的n次幂\n\n");
	printf("           9.计算一个多项式在x=a处的值                           10.两个多项式的商和余式\n\n");
	printf("           11.求两个多项式的最大公约式                           12.求两个多项式的最小公倍式\n\n");
	printf("           13.求一个多项式的n阶导函数                            14.求一个多项式的不定积分\n\n");
	printf("           15.求一个多项式在区间[a, b]上的定积分                 16.清屏并显示所有多项式\n\n"  );
	printf("           17.退出\n\n");
}
void descend_polyn(polynomial &P) {
	//对无序多项式排序，使它的指数从大到小排列
	polynomial pre,p;
	int i = 0;
	float j = 0;
	for(pre=P->next;pre!=NULL;pre=pre->next){
		for(p=pre->next;p!=NULL;p=p->next){
			if (pre->expn < p->expn) {
				i = p->expn;
				p->expn = pre->expn;
				pre->expn = i;
				j = p->coef;
				p->coef = pre->coef;
				pre->coef = j;
			}
		}
	}
}//链表指数排序
void delete_0(polynomial &P) {
	//删除链表中系数为零的项
	polynomial p,pre,q;
	pre=P;p=pre->next;
	while(p!=NULL){
		if(p->coef==0){
			q=p;
			pre->next=p->next;
			p=pre->next;
			free(q);
		}
		else{
			pre=pre->next;
			p=p->next;
		}
	}
}
void merge_polyn(polynomial &P) {
	//合并有序多项式中的同类项 
    if(P==NULL) return;
	polynomial pre,p,p1;
	for(pre=P->next;pre!=NULL&&pre->next!=NULL;pre=pre->next)
	{
		p=pre->next;
		while(p!=NULL)
		{
			if(p->expn==pre->expn){
				pre->coef=pre->coef+p->coef;
				for(p1=pre;p1->next!=p;p1=p1->next);
				p1->next=p->next;
				free(p);
				p=pre;
			}
			p=p->next;
		}
	}
}//合并有序多项式中的同类项 
void creat_polyn(polynomial &P){
//依次输入系数和指数，创建有序链表
	int m,i;
	polynomial p,pre; 
	printf("接下来要输入的多项式共有几项？：");
	while(scanf("%d",&m)!=1||m<=0){
        printf("输入不合法，请输入大于零的数！");
        printf("请输入多项式项数：");
        while (getchar()!='\n') continue; 
	}
	while (getchar()!='\n') continue;
	P=(lnode *)malloc(sizeof(lnode));
	pre=P;
	for(i=0;i<m;i++){
		p=(lnode *)malloc(sizeof(lnode));
		printf("请输入第%d项系数：",i+1);
		while(scanf("%f",&p->coef)!=1){
			printf("输入不合法，请输入一个实数！");
			while (getchar()!='\n') continue; 
		}
		while (getchar()!='\n') continue;
		printf("请输入第%d项指数：",i+1);
		while(scanf("%d",&p->expn)!=1||p->expn<0){
			printf("输入不合法，请输入大于等于零的数！");
            printf("请输入系数：");
            while (getchar()!='\n') continue;
		}
		while (getchar()!='\n') continue;
		pre->next=p;
		pre=p;
	    pre->next=NULL;
	}
	descend_polyn(P);
	merge_polyn(P);
    delete_0(P);
}//创建链表
void print_polyn(polynomial &P){
//将链表打印出来
    if(P==NULL){
		printf("该多项式不存在");
		return ;
	}
    polynomial p=P->next;
    if(p==NULL)
		printf("0");
	if(p!=NULL){
    	if(p->expn==0){                                       //打印第一项 
            printf("%f",p->coef);
		}
        if(p->expn==1){
            if(p->coef==1) printf("x");
	 	    if(p->coef==-1) printf("-x");
		    if(p->coef!=1&&p->coef!=-1) printf("%fx",p->coef);
		}
		if(p->expn>1) {
			if(p->coef==1) printf("x^%d",p->expn);
            if(p->coef==-1) printf(" -x^%d",p->expn);
			if(p->coef!=-1&&p->coef!=1) printf("%fx^%d",p->coef,p->expn);
		}
        for(p=p->next;p!=NULL;p=p->next){                         //打印第二项及以后的项（带符号） 
            if(p->coef>0){
			    if(p->expn==0) printf("+%f",p->coef);
                if(p->expn==1){
			    	if(p->coef==1) printf("+x");
				    else printf("+%fx",p->coef);
				}
			    if(p->expn>1){
			    	if(p->coef==1) printf("+x^%d",p->expn);
				    else printf("+%fx^%d",p->coef,p->expn);
				}
			}
	    	else{
                if(p->expn==0) printf("%f",p->coef);
                if(p->expn==1){
                    if(p->coef==-1) printf("-x");
				    else printf("%fx",p->coef);
				}
			    if(p->expn>1){
                    if(p->coef==1) printf("-x^%d",p->expn);
				    else printf("%fx^%d",p->coef,p->expn);
				}
			} 
		}
	}
}//打印链表
void destroy_polyn(polynomial &P){
//销毁链表
    polynomial p=P->next,q;
	while(p!=NULL){
        q=p;
	    p=p->next;
        P->next=p;
		free(q);                 //删除所有带数据节点 
	}
	free(P);
	P=NULL;                     //删除头结点 
}//销毁链表
void copy_polyn(polynomial &Pa, polynomial &Pb){
//复制链表
    polynomial p,q,qre;                      //qre用来做q的前指针 
	Pb=(lnode *)malloc(sizeof(lnode));
	qre=Pb;
	for(p=Pa->next;p!=NULL;p=p->next){
	    q=(lnode *)malloc(sizeof(lnode));
		q->coef=p->coef;
		q->expn=p->expn;
        qre->next=q;
		qre=q;
		qre->next=NULL;
	}
}//复制链表
void add_polyn(polynomial &Pa, polynomial &Pb){
//两个多项式相加求和，pb加在pa上，然后释放pb空间
    polynomial p,pa;
	p=Pa->next;   
	if(Pa==NULL) {
		printf("\n第一个多项式不存在");
		return ;
	}
	if(Pb==NULL) {
		printf("\n第二个多项式不存在");
		return ;
	}
	pa=Pa;
	while(p!=NULL){                   //找到尾结点 
		pa=p;
		p=p->next;
	}                         
    pa->next=Pb->next;                //将Pb链在Pa后面成为新的多项式，再整理 
	free(Pb);
    descend_polyn(Pa);
    merge_polyn(Pa);
	delete_0(Pa);
}//多项式相加
void minus_polyn(polynomial &Pa, polynomial &Pb){
//两个多项式相减   pa减pb 在pa上修改 然后释放pb空间
    polynomial p,q,pa,pb;
    if(Pa==NULL) {
		printf("\n被减式多项式不存在");
		return ;
	}
	if(Pb==NULL) {
		printf("\n减式多项式不存在");
		return ;
	}
	p=Pa->next;
	q=Pb->next;
	pa=Pa;
	pb=Pb;
	while(q!=NULL){
		q->coef=0-q->coef;              //将Pb置负，转化为加法 
        pb=q;
		q=q->next;
	}
    while(p!=NULL){                     //找到尾结点 
		pa=p;
		p=p->next;
	}
    pa->next=Pb->next;                  //将变负后的Pb链在Pa后面成为新的多项式，再整理
	free(Pb);
	Pb=NULL;
    descend_polyn(Pa);
    merge_polyn(Pa);
	delete_0(Pa);
}//多项式相减
void mult_polyn(polynomial &Pa,polynomial &Pb,polynomial &Pc){
//两个多项式相乘，结果存入Pc 
    if(Pa==NULL){
    	printf("ERROR!第一个多项式不存在！！");
		return ; 
	} 
	if(Pb==NULL){
    	printf("ERROR!第二个多项式不存在！！");
		return ; 
	}
	polynomial pa,pb,pc,r;int e;float c;
	Pc=(lnode*)malloc(sizeof(lnode));
	pa=Pa->next;
	pc=Pc;
	Pc->next=NULL;
	while(pa!=NULL){
		pb=Pb->next;
		while(pb!=NULL){
			e=pa->expn+pb->expn;
			c=pa->coef*pb->coef;
			pb=pb->next; 
			r=(lnode*)malloc(sizeof(lnode));
			r->expn=e;
			r->coef=c;
			pc->next=r;
			pc=pc->next;
			pc->next=NULL;
		}
		pa=pa->next;
	}
	descend_polyn(Pc);
    merge_polyn(Pc);
	delete_0(Pc);
	if(Pc->next==NULL)                           //如果去零后没有一项，则添加一常数项0 
	{
		Pc->next=(lnode*)malloc(sizeof(lnode));
		Pc->next->coef=0;
		Pc->next->expn=0;
		Pc->next->next=NULL;
	}
}//两个多项式相乘
void power_polyn(polynomial &Pa,polynomial &Pb,int n){
//求多项式的n次幂，并存入Pb 
	int i;
	polynomial Pc;
	if(!Pa)
	{	
		printf("ERROR!多项式不存在！\n");
		return;
	}
	if(n==1)
	{
		mult_polyn(Pa,Pa,Pb);
	}
	if(n>=2)
	{
	    mult_polyn(Pa,Pa,Pb);
		for(i=1;i<n;i++)
		{   
			mult_polyn(Pa,Pb,Pc);
			destroy_polyn(Pb);
			Pb=Pc;
		}
	}
}
void calculate_polyn(polynomial &P){
//多项式求值
	float f,m=0;
    polynomial p=P->next;
	if(P==NULL) {
		printf("\n多项式不存在");
		return ;
	}
	printf("请输入x的值：");
	while(scanf("%f",&f)!=1){
		printf("输入不合法，请输入一个实数！");
		while (getchar()!='\n') continue; 
	}
	while (getchar()!='\n') continue;
    for(p=P->next;p!=NULL;p=p->next){
        if(p->expn==0)  m+=p->coef;
		if(p->expn!=0){
           m+=p->coef*pow(f,p->expn);
		}
	}
	printf("当x=%d时，该多项式的值为%f\n",f,m);
}//多项式求值
void div_polyn(polynomial &Pa,polynomial &Pb,polynomial &Pc,polynomial &Pd){
	polynomial d,pa,pb,pc,pcr;int t;
	if(Pa==NULL) {
		printf("\n被除式多项式不存在");
		return ;
	}
	pa=Pa->next;
	pb=Pb->next;
	Pc=(lnode*)malloc(sizeof(lnode));
	pcr=Pc;                                        //用pcr表示pc的pre 
	if(pb==NULL)
	{
		printf("除数为0,error！");
		return;
	}
	t=pb->expn;
	if(pa->expn<t)                               //如果b的最高项比a的最高项还高，商为0，余数为a 
	{
		Pc->next=(lnode*)malloc(sizeof(lnode));
		Pc->next->coef=0;
		Pc->next->expn=0;
		Pc->next->next=NULL;
		copy_polyn(Pa,Pd);
		return;
	}
	while(pa->expn>=t)
	{
		pc=(lnode*)malloc(sizeof(lnode));
		pcr->next=pc;
		delete_0(Pb);
		pc->coef=(pa->coef)/(pb->coef);             //将除出来的一项存入Pc 
		pc->expn=pa->expn-pb->expn;
		pc->next=NULL;
		pcr=pc;
		mult_polyn(Pb,Pc,d);
		minus_polyn2(Pa,d,Pd);
	    if(Pd->next==NULL)break;
		pa=Pd->next;
	}
}
void minus_polyn2(polynomial &a,polynomial &b,polynomial &d){
//a减去b，将结果存入d 
	polynomial pa1,pb1,pc1,p1,s1;float temp;
	d=(lnode*)malloc(sizeof(lnode));
	d->next=NULL;
	pc1=d;
	pa1=a->next;
	pb1=b->next;
	while(pa1!=NULL&&pb1!=NULL)
	{
		if(pa1->expn==pb1->expn){
			temp=(pa1->coef)-(pb1->coef);
			if(fabs(temp)>0.0001)                     //如果不是很接近，则将该项加入链表 
			{
				s1=(lnode*)malloc(sizeof(lnode));
				pc1->next=s1;
				pc1=pc1->next;
				pc1->coef=temp;
				pc1->expn=pa1->expn;
			}
			pa1=pa1->next;
			pb1=pb1->next;
		}
		else
		{
			s1=(lnode*)malloc(sizeof(lnode));
			if(pa1->expn>pb1->expn)
			{
				pc1->next=s1;
				pc1=pc1->next;
				pc1->coef=pa1->coef;
				pc1->expn=pa1->expn;
				pa1=pa1->next;
			}
			else
			{
	            pc1->next=s1;
				pc1=pc1->next;
				pc1->coef=-(pb1->coef);
				pc1->expn=pb1->expn;
				pb1=pb1->next;
			}
		}
	}
	if(pa1!=NULL)
	{p1=pa1;
     	while(p1!=NULL)
		{
			pc1->next=(lnode*)malloc(sizeof(lnode));
			pc1=pc1->next;
			pc1->coef=p1->coef;
			pc1->expn=p1->expn;
			p1=p1->next;
		}	
	}
	else
	{p1=pb1;
         while(p1!=NULL)
		{
			pc1->next=(lnode*)malloc(sizeof(lnode));
			pc1=pc1->next;
			pc1->coef=-(p1->coef);
			pc1->expn=p1->expn;
			p1=p1->next;
		}
	} 
	pc1->next=NULL;
}
void gcd_polyn(polynomial &pa,polynomial &pb,polynomial &pc){
	polynomial a,b,c,d;
	if(pa==NULL) {
		printf("\n第一个多项式不存在");
		return ;
	}	
	if(pb==NULL) {
		printf("\n第二个多项式不存在");
		return ;
	}
	copy_polyn(pa,a);
	copy_polyn(pb,b);
	div_polyn(a,b,c,d);
	while(d->next!=NULL)         //辗转相除法直至余数项d为0 
	{
       copy_polyn(b,a);
	   destroy_polyn(b);
	   copy_polyn(d,b);
	   destroy_polyn(d);
	   div_polyn(a,b,c,d);
	}
/*	if(b->next->coef != 1)                            //将最高项系数变为1 ???
	{	
		double COEF = b->next->coef; a = b->next;
		while(a != NULL)
		{
			a->coef /= COEF;
			a = a->next;
		} 
	}*/
	pc=b;
}
void diff_polyn(polynomial &pl,int k){
//多项式求导
	polynomial pa,par;int i;
	if(pl==NULL) {
		printf("\n多项式不存在");
		return ;
	}
	pa=pl->next;
	par=pl;
	while(pa!=NULL)
	{
		if(pa->expn<k)
		{
			par->next=pa->next;            //对该项指数小于k，置零 
			pa=par->next;
		}
		else
		{
			for(i=0;i<k;i++){              //若指数大于k，对该项求k次导 
			 pa->coef=pa->coef*(pa->expn);
			 pa->expn=pa->expn-1;
			}
			pa=pa->next;
			par=par->next;
		}
	}
	if(pl->next==NULL)
	{
		printf("0");
	}
}//多项式求导
void indefinite_integral(polynomial &pl,polynomial &a){
//求多项式的不定积分
	polynomial p,pa,par;
	if(pl==NULL) {
		printf("\n多项式不存在");
		return ;
	}
	p=pl->next;
	a=(lnode*)malloc(sizeof(lnode));
	par=a;
	while(p!=NULL)
	{
		pa=(lnode*)malloc(sizeof(lnode));       //遍历，对每一项求不定积分 
		pa->coef=(p->coef)/(p->expn+1);
		pa->expn=p->expn+1;
		par->next=pa;par=pa;
		p=p->next;
	}
	pa->next=NULL;
}//求多项式的不定积分
void definite_integral(polynomial &pl,float a,float b){
//求多项式的定积分
	polynomial pa;
	if(pl==NULL) {
		printf("\n多项式不存在");
		return ;
	}
	indefinite_integral(pl,pa);
	printf("值为%f\n",(evaluation_polyn(pa,b)-evaluation_polyn(pa,a)));
}//求多项式的定积分
double evaluation_polyn(polynomial &P,float k){
//多项式求值，并返回求出的值m 
	float m=0;
	if(P==NULL) {
		printf("\n多项式不存在");
		return 0;
	}
    polynomial p=P->next;
    for(p=P->next;p!=NULL;p=p->next){
        if(p->expn==0) m+=p->coef;
		if(p->expn!=0){
			m+=(p->coef)*pow(k,p->expn);        //m累加 
		}
	}
	 return m;
}
int get_order(){
//用来获得标准位置，返回一个用户要的位置下标（只能取得0~99的数字） 
	int i=0;
	while(scanf("%d",&i)!=1||(i<0||i>=MAX_TERMS_NUMBER)){
		printf("ERROR!请输入0~99的数！");
		while (getchar()!='\n') continue; 
	}
	while (getchar()!='\n') continue; 
	return i;
}
int main(){
    int x,j=0,k=0,i,l,m;                             //j,k是一组多项式存放的位置下标
	polynomial P[MAX_TERMS_NUMBER],p1,p2,p3;         //P里面放的都是结构体地址 La Lb...的首地址
	float a,b;
	polynomial s[MAX_TERMS_NUMBER];
	for(j=0;j<MAX_TERMS_NUMBER;j++)
	{
		P[j]=NULL;
	}
	print_menu();
	for(;;)
	{
		printf("要执行的操作为？（请输入1~17的数字）：");
		while(scanf("%d",&x)!=1||(x<=0||x>=18)){
			printf("ERROR!请输入1~17的数字!");	
			while (getchar()!='\n') continue; 
		}
		while (getchar()!='\n') continue; 
		switch(x){
			case 1:
				printf("请输入要存放多项式的位置的下标：");
				k=get_order();
				creat_polyn(P[k]);
				printf("创建成功\n");
				print_menu();
				break;
			case 2:
				printf("输入要打印的多项式位置下标：");
				k=get_order();
				print_polyn(P[k]);
				printf("\n");
				print_menu();
				break;
			case 3:   
				printf("输入要销毁的多项式位置下标：");
				k=get_order();
				destroy_polyn(P[k]);
				printf("销毁成功\n");
				print_menu();
				break;
			case 4:
				printf("输入要复制的多项式位置下标：");
				k=get_order();
				printf("输入复制后的多项式存储的位置下标：");
				j=get_order();
				copy_polyn(P[k],P[j]);
				print_polyn(P[j]);
                printf("\n");
				print_menu();
				break;
			case 5:
			    printf("请输入第一个多项式存放的位置：");
				j=get_order();
				printf("请输入第二个多项式存放的位置：");
				k=get_order();
				add_polyn(P[j], P[k]);
				print_polyn(P[j]);
                printf("\n");
				print_menu();
				break;
			case 6:
                printf("请输入第一个多项式（被减数）存放的位置：");
				j=get_order();
				printf("请输入第二个多项式（减数）存放的位置：");
				k=get_order();
				minus_polyn(P[j], P[k]);
				print_polyn(P[j]);
                printf("\n");
				print_menu();
				break;
			case 7:
				printf("输入要相乘的第一个多项式位置下标：");
				j=get_order();
				printf("输入要相乘的第二个多项式位置下标：");
				k=get_order();
				printf("输入要存放新多项式位置下标：");
				l=get_order();
				mult_polyn(P[j],P[k],P[l]);
				print_menu();
				break;
			case 8:
				printf("输入要做幂运算的多项式位置下标：");
				k=get_order();
				printf("要做几次方？");
				while(scanf("%d",&m)!=1||m<=1){
					printf("ERROR!请输入大于等于2的整数！");
					while (getchar()!='\n') continue; 
				}
				while (getchar()!='\n') continue; 
				printf("输入要存放新多项式位置下标：");
			    l=get_order();
				power_polyn(P[k],P[l],m-1);
				print_menu();
				break;
			case 9:
                printf("输入要求值的多项式位置下标：");
				k=get_order();
				calculate_polyn(P[k]);
				print_menu();
				break;
			case 10:
				printf("输入要被除的的多项式位置下标：");
				j=get_order();
				printf("输入要当做除数的的多项式位置下标：");
				k=get_order();
				printf("输入要存放商的位置下标：");
				l=get_order();
				printf("输入要存放余数的位置下标："); 
				i=get_order();
				div_polyn(P[j],P[k],P[l],P[i]);
				print_menu();
				break;
			case 11:
		   		printf("输入求最大公因式的第一个多项式：");
				j=get_order();
				printf("输入求最大公因式的第二个多项式：");
				k=get_order();
				printf("输入存放最大公因式位置下标：");
				l=get_order();
				gcd_polyn(P[j],P[k],P[l]);
				print_menu();
				break;
			case 12:
				printf("输入求最小公倍式的第一个多项式：");
				j=get_order();
				printf("输入求最小公倍式的第二个多项式：");
				k=get_order();
				printf("输入存放最小公倍式位置下标：");
				l=get_order();
		   		mult_polyn(P[j],P[k],p1);
		   		gcd_polyn(P[j],P[k],p2);
				div_polyn(p1,p2,P[l],p3);
				print_menu();
				break;
			case 13:
				printf("输入要求微分的的多项式位置下标：");
				j=get_order();
				printf("输入要求导的次数：");
				while(scanf("%d",&k)!=1||x<=0){
					printf("ERROR!请输入大于零的整数！");	
					while (getchar()!='\n') continue; 
				}
				while (getchar()!='\n') continue;
				diff_polyn(P[j],k);
				print_menu();
				break;
			case 14: 
				printf("输入用来求不定积分的的多项式位置下标：");
				j=get_order();
				printf("输入存放新多项式位置下标：");
				k=get_order();
				indefinite_integral(P[j],P[k]);
	            print_polyn(P[k]);
	            printf("+C");
				printf("\n");
				print_menu();
				break;
			case 15:
				printf("输入要求定积分的的多项式位置下标：");
				j=get_order();
				printf("输入积分域的下界：");
				while(scanf("%f",&a)!=1){
					printf("ERROR!请输入正确的实数！");	
					while (getchar()!='\n') continue; 
				}
				while (getchar()!='\n') continue; 
				printf("输入积分域的上界：");
				while(scanf("%f",&b)!=1){
					printf("ERROR!请输入正确的实数！");	
					while (getchar()!='\n') continue; 
				}
				while (getchar()!='\n') continue; 
				definite_integral(P[j],a,b);
				print_menu();
				break;
			case 16:
				system("cls");
				print_menu();
				for(i=0;i<MAX_TERMS_NUMBER;i++){
					if(P[i]!=NULL){
						printf("第%d个多项式为：",i);
						print_polyn(P[i]);
						printf("\n");
					}
				}
				break;
			case 17:
			    exit(0);
			default :
				break;
			}	
	}
	return 0;
}