北邮数据结构上机 一元多项式

北京邮电大学电信工程学院数据结构实验报告实验名称：实验一题目3一元多项式学生姓名：卢跃凯班级：信通12班班内序号：13号学号：日期：2013/11/131．实验要求1 实验目的通过选择下面两个题目之一进行实现，掌握如下内容：➢掌握二叉树基本操作的实现方法➢学习使用二叉树解决实际问题的能力题目1➢根据二叉树的抽象数据类型的定义，使用二叉链表实现一个二叉树。

➢二叉树的基本功能：➢1、二叉树的建立➢2、前序遍历二叉树➢3、中序遍历二叉树➢4、后序遍历二叉树➢5、按层序遍历二叉树➢6、求二叉树的深度➢7、求指定结点到根的路径➢8、二叉树的销毁➢9、其他：自定义操作➢编写测试main()函数测试线性表的正确性2. 程序分析第1页2.1 存储结构采用二叉树的存储结构，其中每个二叉树的结点定义了一个结构体BiNode<T>*lch;，该结构体包含三个元素，分别是一个T类型的数据域data，一个指向T类型的指针左孩子BiNode<T>*lch;，一个指向T类型的指针右孩子，示意图如图所示。

在对二叉树的层序遍历算法的实现过程中，采用了队列的存储结构。

队列的存储结构示意如图所示：在二叉树的创建中，对于二叉树中每个结点的data 域的赋值，我们事先把这些data 储存在一个数组中，通过对数组元素的调用事先对二叉树中每个结点的data 域的赋值。

2.2 关键算法分析一：二叉树的建立：A．自然语言描述：1 首先判断调用的数组是否为空，如果该数组不为空，则把调用的数组的第一个元素的赋给根节点的data 域。

北京邮电大学信息与通信工程学院2 采用递归的思想，分别将根节点的左右孩子作为根节点，递归调用该函数。

完成对左右子树的赋值。

3如果为空，直接将一个已经初始化好的根节点置为空。

B．代码详细分析：void BiTree<T>::Create (BiNode<T>*&R,T data[],int i){//i表示位置，从1开始if(data[i-1]!=0){R = new BiNode<T>; //创建根结点R->data = data[i-1];Create(R->lch,data,2*i);//创建左子树Create(R->rch,data,2*i+1);//创建右子树}elseR = NULL;}第3页二：前序遍历二叉树：A.自然语言描述：1.首先判断根结点是否为空，如果不为空，输出根结点data域中所存储的值。

一元多项式计算：程序要求：1）、能够按照指数降序排列建立并输出多项式；2）、能够完成两个多项式的相加、相减，并将结果输入。

概要设计：1.功能：将要进行运算的多项式输入输出。

2.数据流入：要输入的多项式的系数与指数。

3.数据流出：合并同类项后的多项式。

4.程序流程图：多项式输入流程图如图3.2.1所示。

5.测试要点：输入的多项式是否正确，若输入错误则重新输入2、多项式的加法（1）功能：将两多项式相加。

（2）数据流入：输入函数。

（3）数据流出：多项式相加后的结果。

（4）程序流程图：多项式的加法流程图如图3.2.2所示。

（5）测试要点：两多项式是否为空，为空则提示重新输入，否则，进行运算。

3、多项式的减法（1）功能：将两多项式相减。

（2）数据流入：调用输入函数。

（3）数据流出：多项式相减后的结果。

（4）程序流程图：多项式的减法流程图如图3.2.3所示。

（5）测试要点：两多项式是否为空，为空则提示重新输入，否则，进行运算。

详细代码：#include<iostream>#include<conio.h>#include<stdlib.h>using namespace std; struct Node{float coef;//结点类型int exp;};typedef Node polynomial;struct LNode{polynomial data;//链表类型LNode *next;};typedef LNode* Link;void CreateLink(Link &L,int n);void PrintList(Link L);void PolyAdd(Link &pc,Link pa,Link pb);void PolySubstract(Link &pc,Link pa,Link pb); void CopyLink(Link &pc,Link pa);void PolyMultiply(Link &pc,Link pa,Link pb);int JudgeIfExpSame(Link pa,Link e);void DestroyLink(Link &L);int CompareIfNum(int i);void DestroyLink(Link &L){Link p;p=L->next;while(p){L->next=p->next;delete p;p=L->next;}delete L;L=NULL;}//创建含有n个链表类型结点的项，即创建一个n项多项式void CreateLink(Link &L,int n){if(L!=NULL){DestroyLink(L);}Link p,newp;L=new LNode;L->next=NULL;(L->data).exp=-1;//创建头结点p=L;for(int i=1;i<=n;i++){newp=new LNode;cout<<"请输入第"<<i<<"项的系数和指数:"<<endl;cout<<"系数:";cin>>(newp->data).coef;cout<<"指数:";cin>>(newp->data).exp;if(newp->data.exp<0){cout<<"您输入有误，指数不允许为负值!"<<endl;delete newp;i--;continue;}newp->next=NULL;p=L;if(newp->data.coef==0){cout<<"系数为零，重新输入!"<<endl;delete newp;i--;continue;}while((p->next!=NULL)&&((p->next->data).exp<(newp->data).exp)){p=p->next; //p指向指数最小的那一个}if(!JudgeIfExpSame( L, newp)){newp->next=p->next;p->next=newp;}else{cout<<"输入的该项指数与多项式中已存在的某项相同,请重新创建一个正确的多项式"<<endl;delete newp;DestroyLink(L);CreateLink(L,n); //创建多项式没有成功，递归调用重新创建break;}}}/*判断指数是否与多项式中已存在的某项相同*/int JudgeIfExpSame(Link L,Link e){Link p;p=L->next;while(p!=NULL&&(e->data.exp!=p->data.exp))p=p->next;if(p==NULL)return 0;else return 1;}/*输出链表*/void PrintList(Link L){Link p;if(L==NULL||L->next==NULL)cout<<"该一元多项式为空！"<<endl;else{p=L->next;//项的系数大于的种情况if((p->data).coef>0){if((p->data).exp==0)cout<<(p->data).coef;else if((p->data).coef==1&&(p->data).exp==1)cout<<"x";else if((p->data).coef==1&&(p->data).exp!=1)cout<<"x^"<<(p->data).exp;else if((p->data).exp==1&&(p->data).coef!=1)cout<<(p->data).coef<<"x";else cout<<(p->data).coef<<"x^"<<(p->data).exp; }//项的系数小于的种情况if((p->data).coef<0){if((p->data).exp==0)cout<<(p->data).coef;else if(p->data.coef==-1&&p->data.exp==1)cout<<"-x";else if(p->data.coef==-1&&p->data.exp!=1)cout<<"-x^"<<p->data.exp;else if(p->data.exp==1)cout<<p->data.coef<<"x";else cout<<(p->data).coef<<"x^"<<(p->data).exp; }p=p->next;while(p!=NULL){if((p->data).coef>0){if((p->data).exp==0)cout<<"+"<<(p->data).coef;else if((p->data).exp==1&&(p->data).coef!=1)cout<<"+"<<(p->data).coef<<"x";else if((p->data).exp==1&&(p->data).coef==1)cout<<"+"<<"x";else if((p->data).coef==1&&(p->data).exp!=1)cout<<"+"<<"x^"<<(p->data).exp;else cout<<"+"<<(p->data).coef<<"x^"<<(p->data).exp; }if((p->data).coef<0){if((p->data).exp==0)cout<<(p->data).coef;else if(p->data.coef==-1&&p->data.exp==1)cout<<"-x";else if(p->data.coef==-1&&p->data.exp!=1)cout<<"-x^"<<p->data.exp;else if(p->data.exp==1)cout<<p->data.coef<<"x";else cout<<(p->data).coef<<"x^"<<(p->data).exp;}p=p->next;}}cout<<endl;}/*把一个链表的内容复制给另一个链表*/void CopyLink(Link &pc,Link pa){Link p,q,r;pc=new LNode;pc->next=NULL;r=pc;p=pa;while(p->next!=NULL){q=new LNode;q->data.coef=p->next->data.coef;q->data.exp=p->next->data.exp;r->next=q;q->next=NULL;r=q;p=p->next;}}/*将两个一元多项式相加*/void PolyAdd(Link &pc,Link pa,Link pb){Link p1,p2,p,pd;CopyLink(p1,pa);CopyLink(p2,pb);pc=new LNode;pc->next=NULL;p=pc;p1=p1->next;p2=p2->next;while(p1!=NULL&&p2!=NULL){if(p1->data.exp<p2->data.exp){p->next=p1;p=p->next;p1=p1->next;}else if(p1->data.exp>p2->data.exp){p->next=p2;p=p->next;p2=p2->next;}else{p1->data.coef=p1->data.coef+p2->data.coef;if(p1->data.coef!=0){p->next=p1;p=p->next;p1=p1->next;p2=p2->next;}else{pd=p1;p1=p1->next;p2=p2->next;delete pd;}}}if(p1!=NULL){p->next=p1;}if(p2!=NULL){p->next=p2;}}/*将两个多项式相减*/void PolySubstract(Link &pc,Link pa,Link pb) {Link p,pt;CopyLink(pt,pb);p=pt;while(p!=NULL){(p->data).coef=(-(p->data).coef);p=p->next;}PolyAdd(pc,pa,pt);DestroyLink(pt);}//清屏函数void Clear(){system("pause");system("cls");}/*将两个一元多项式相乘*/void PolyMultiply(Link &pc,Link pa,Link pb) {Link p1,p2,p,pd,newp,t;pc=new LNode;pc->next=NULL;p1=pa->next;p2=pb->next;while(p1!=NULL){pd=new LNode;pd->next=NULL;p=new LNode;p->next=NULL;t=p;while(p2){newp=new LNode;newp->next=NULL;newp->data.coef=p1->data.coef*p2->data.coef;newp->data.exp=p1->data.exp+p2->data.exp;t->next=newp;t=t->next;p2=p2->next;}PolyAdd(pd,pc,p);CopyLink(pc,pd);p1=p1->next;p2=pb->next;DestroyLink(p);DestroyLink(pd);}}//菜单函数void Menu(){cout<<""<<endl;cout<<endl;cout<<"\t=========================一元多项式的简单运算========================="<<endl;cout<<"\t\t\t\t\t\t\t\t "<<endl;cout<<"\t\t\t [1] 创建要运算的两个一元多项式\t\t "<<endl; cout<<"\t\t\t [2] 将两个一元多项式相加\t\t\t "<<endl; cout<<"\t\t\t [3] 将两个一元多项式相减\t\t\t "<<endl; cout<<"\t\t\t [4] 将两个一元多项式相乘\t\t\t "<<endl; cout<<"\t\t\t [5] 显示两个一元多项式\t\t\t "<<endl;cout<<"\t\t\t [6] 销毁所创建的二个多项式\t\t "<<endl; cout<<"\t\t\t [7] 退出\t\t\t\t\t "<<endl;cout<<"\t\t\t\t\t\t\t\t "<<endl;cout<<"\t=========================一元多项式的简单运算========================="<<endl;cout<<endl;cout<<"\t\t 请选择:";}//判断输入的整数是不是为到的数字int CompareIfNum(int i){if(i>0&&i<8)return 0;else return 1;}void main(){{system("color b");//system("pause");system("color a");//system("pause");}int n;Link L,La=NULL,Lb=NULL;//La,Lb分别为创建的两个多项式int choose;while(1){Menu(); //调用菜单函数cin>>choose;switch(choose){case 1:cout<<"请输入你要运算的第一个一元多项式的项数:"<<endl; cin>>n;if(CompareIfNum(n)==1){cout<<"您的输入有误，请重新输入……"<<endl;Clear();break;}CreateLink(La,n);cout<<"请输入你要运算的第二个一元多项式的项数:"<<endl; cin>>n;if(CompareIfNum(n)==1){cout<<"您的输入有误，请重新输入……"<<endl;Clear();break;}CreateLink(Lb,n);Clear();break;case 2:if(La==NULL||Lb==NULL){cout<<"您的多项式创建有误，请重新选择……"<<endl; Clear();break;}PolyAdd(L,La,Lb);cout<<""<<endl;cout<<"待相加的两个一元多项式为："<<endl;cout<<""<<endl;cout<<"A的多项式为：";PrintList(La);cout<<""<<endl;cout<<"B的多项式为：";PrintList(Lb);cout<<""<<endl;cout<<"相加后的结果为：";PrintList(L);cout<<""<<endl;Clear();DestroyLink(L);break;case 3:if(La==NULL||Lb==NULL){cout<<"您的多项式创建有误，请重新选择……"<<endl; Clear();break;}PolySubstract(L,La,Lb);cout<<"相减的两个一元多项式为："<<endl;cout<<""<<endl;cout<<"A的多项式为：";PrintList(La);cout<<""<<endl;cout<<"B的多项式为：";PrintList(Lb);cout<<""<<endl;cout<<"相减后的结果为：";PrintList(L);cout<<""<<endl;Clear();DestroyLink(L);break;case 4:if(La==NULL||Lb==NULL){cout<<"您的多项式创建有误，请重新选择……"<<endl; Clear();break;}PolyMultiply(L,La,Lb);cout<<"相乘的两个一元多项式为："<<endl;cout<<""<<endl;cout<<"A的多项式为：";PrintList(La);cout<<""<<endl;cout<<"B的多项式为：";PrintList(Lb);cout<<""<<endl;cout<<"相乘后的结果为：";PrintList(L);DestroyLink(L);cout<<""<<endl;Clear();break;case 5:if(La==NULL||Lb==NULL){cout<<"您的多项式创建有误，请重新选择……"<<endl; Clear();break;}cout<<"一元多项式A为："<<endl;PrintList(La);cout<<""<<endl;cout<<"一元多项式B为："<<endl;PrintList(Lb);cout<<""<<endl;Clear();break;case 6:if(La&&Lb){DestroyLink(La);DestroyLink(Lb);cout<<"多项式销毁成功！"<<endl;Clear();}else{cout<<"多项式不存在，请重新选择^^^"<<endl;Clear();}break;case 7:exit(0); //exit(0)强制终止程序，返回状态码表示正常结束default:cout<<"您的输入有误，请重新选择操作……"<<endl;Clear();break;}}}。

数据结构一元多项式的运算正文：1. 引言本文档旨在介绍数据结构中一元多项式的运算方法。

一元多项式是指在一个变量上的多项式，其中每一项由一个系数和一个指数组成。

我们将会讨论一元多项式的表示、存储和基本运算，包括多项式的加法、减法、乘法和求导等操作。

2. 一元多项式的表示和存储2.1 一元多项式的定义一元多项式是指在一个变量x上的多项式，每一项由一个系数和一个指数组成，例如：2x^3 - 5x^2 + 3x + 1.其中，2、-5、3和1分别是系数，3、2、1和0分别是指数。

2.2 一元多项式的表示方法一元多项式可以使用数组、链表或其他数据结构来表示。

在本文中，我们选择使用数组来表示一元多项式。

数组的索引代表指数，数组的元素代表系数。

例如，多项式 2x^3 - 5x^2 + 3x + 1 可以表示为 [1, 3, -5, 2]。

2.3 一元多项式的存储结构为了表示一元多项式，我们可以使用一个数组来存储多项式的系数。

数组的长度应该比多项式的最高指数大1.数组的索引代表指数，数组的元素代表系数。

例如，数组 [1, 3, -5, 2] 表示的多项式 2x^3 - 5x^2 + 3x + 1 中，索引0对应指数为3的项，索引1对应指数为2的项，以此类推。

3. 一元多项式的基本运算3.1 一元多项式的加法一元多项式的加法是指将两个多项式相加，并合并同类项。

具体操作如下：- 将两个多项式的系数相加，并将结果存储在一个新的多项式中。

- 遍历新的多项式，将相邻的相同指数的项合并。

3.2 一元多项式的减法一元多项式的减法是指将一个多项式减去另一个多项式，并合并同类项。

具体操作如下：- 将两个多项式的系数相减，并将结果存储在一个新的多项式中。

- 遍历新的多项式，将相邻的相同指数的项合并。

3.3 一元多项式的乘法一元多项式的乘法是指将两个多项式相乘，并合并同类项。

具体操作如下：- 遍历一个多项式的每一项，与另一个多项式的每一项相乘。

数据结构一元多项式的运算数据结构一元多项式的运算1、引言1.1 研究背景1.2 研究目的2、一元多项式的定义2.1 一元多项式的概念2.2 一元多项式的表示方法2.3 一元多项式的次数和系数2.4 一元多项式的零多项式和常数项2.5 一元多项式的加法运算2.6 一元多项式的减法运算2.7 一元多项式的乘法运算3、一元多项式的特殊运算3.1 一元多项式的乘方运算3.2 一元多项式的取余运算3.3 一元多项式的求导运算3.4 一元多项式的积分运算3.5 一元多项式的复合运算4、一元多项式的应用4.1 一元多项式在数学中的应用4.2 一元多项式在计算机科学中的应用4.3 一元多项式在工程领域中的应用5、实例分析5.1 实例一：一元多项式的相加减5.2 实例二：一元多项式的乘法运算5.3 实例三：一元多项式的特殊运算应用6、结论附件：附件一：一元多项式的代码实现示例法律名词及注释：1.一元多项式: 指仅有一个未知数的多项式。

2.多项式的次数: 多项式中各项最高次幂的次数。

3.多项式的系数: 多项式中各项中未知数的系数。

4.零多项式: 所有系数均为0的多项式。

5.常数项: 多项式中次数为0的项，即常数项。

6.多项式的加法运算: 将两个多项式相同次项的系数相加。

7.多项式的减法运算: 将两个多项式相同次项的系数相减。

8.多项式的乘法运算: 将两个多项式的各项相乘，并根据指数相加合并同类项。

9.多项式的乘方运算: 将一个多项式自乘n次。

10.多项式的取余运算: 两个多项式相除后的余数部分。

11.多项式的求导运算: 对多项式中的每一项进行求导操作。

12.多项式的积分运算: 对多项式中的每一项进行积分操作。

13.多项式的复合运算: 将一个多项式代入另一个多项式中进行运算。

数据结构一元多项式的运算第一章引言在计算机科学中，数据结构是指一组数据和数据之间的关系，以及在这组数据上定义的一组操作。

数据结构是计算机算法的基础，它能够提高数据的组织和处理效率。

本文将详细介绍一元多项式的运算，包括多项式的表示方式以及常见的运算操作。

第二章多项式的表示方式多项式可表示为一系列项的和，其中每一项由系数和指数组成。

常见的表示方式有两种：________1.数组表示法：________将多项式的每一项按照指数从小到大的顺序存储在一个数组中。

数组的下标表示项的指数，数组的元素存储项的系数。

例如，多项式 P(x) = 2x^3 + 3x^2 ●4x + 1 可表示为数组 1, -4, 3, 2。

2.链表表示法：________将多项式的每一项作为链表的一个节点，节点包含指数和系数两个属性，通过链表的方式连接起来。

例如，多项式 P(x) = 2x^3 + 3x^2 ●4x + 1 可表示为链表的形式：________2 ->3 -> -4 -> 1---● ---● ---● ----x^3 x^2 x 1第三章多项式的基本运算多项式的基本运算包括多项式的加法、减法、乘法和求导。

1.多项式的加法：________将两个多项式相加，实际上是将对应指数的系数相加。

例如，多项式 P(x) = 2x^3 + 3x^2 ●4x + 1和多项式 Q(x) = x^2 + 2x + 3 相加得到多项式 R(x) = 2x^3 +4x^2 ●2x + 4。

2.多项式的减法：________将一个多项式减去另一个多项式，实际上是将对应指数的系数相减。

例如，将多项式 P(x) 减去多项式 Q(x) 得到多项式 R(x) = 2x^3 + 2x^2 ●6x ●2。

3.多项式的乘法：________将两个多项式相乘，实际上是将一个多项式的每一项与另一个多项式的每一项相乘，然后将结果相加。

例如，将多项式 P(x) = 2x^3 + 3x^2 ●4x + 1 与多项式 Q(x) =x^2 + 2x + 3 相乘得到多项式 R(x) = 2x^5 + 7x^4 ●4x^3 +9x^2 ●5x + 3。

一元多项式相加问题实验报告本实验的目的是进一步熟练掌握应用链表处理实际问题的能力。

一、问题描述通过键盘输入两个形如Po+P₁X¹+P₂X²+…+PX的多项式，经过程序运算后在屏幕上输出它们的相加和。

二、数据结构设计分析任意一元多项式的描述方法可知，一个一元多项式的每一个子项都由“系数-指数”两部份组成，因此可将其抽象为包含系数coef、指数 exp、指针域next 构成的链式线性表。

对多项式中系数为0的子项可以不记录它的指数值，将两个多项式分别存放在两个线性表中，然后经过相加后将所得多项式存放在一个新的线性表中，但是不用再开辟新的存储空间，只依靠结点的挪移来构成新的线性表，期间可以将某些不需要的空间回收。

基于这样的分析，可以采用不带头结点的单链表来表示一个一元多项式。

具体数据类型定义为：struct nodefloat coef;//系数域int exp; //指数域struct node *next;};三、功能函数设计1、输入并建立多项式的功能模块具体函数为node *in f un()此函数的处理较为全面，要求用户按照指数递增的顺序和一定的输入格式输入各个系数不为0的子项，输入一个子项建立一个相关结点，当遇到输入结束标志时住手输入。

关键步骤具体如下：(1)控制用户按照指数递增的顺序输入r=a;while(r!=q->next)if(y<=r->exp)cout<<"请按照指数递增顺序输入，请重新输入";cin>>x>>y;break;r=r->next;从头开始遍历，若遇到目前输入的指数不是最大时，就跳出循环，让用户重新输入。

(2)当输入的系数为零时，不为其分配存储空间存储while(x==0){cin>>x>>y;continue;}即若系数为0,再也不进行动态分配并新建结点，而是重新提取用户输入的下一个子项的系数和指数，利用continue 进入下一次循环。

数据结构实验报告-一元多项式数据结构课程设计报告课题: 一元多项式姓名：XX学号：201417030218专业班级：XXXX指导教师：XXXX设计时间：2015年12月30日星期三评阅意见：评定成绩：指导老师签名：年月日目录一、任务目标 (3)二、概要设计 (4)三、详细设计 (6)四、调试分析 (8)五、源程序代码 (8)六、程序运行效果图与说明 (15)七、本次实验小结 (16)八、参考文献 (16)一丶任务目标分析 (1) a.能够按照指数降序排列建立并输出多项式b.能够完成两个多项式的相加，相减，并将结果输入要求：程序所能达到的功能：a.实现一元多项式的输入；b.实现一元多项式的输出；c.计算两个一元多项式的和并输出结果；d.计算两个一元多项式的差并输出结果；除任务要求外新增乘法：计算两个一元多项式的乘积并输出结果（2）输入的形式和输入值的范围：输入要求：分行输入，每行输入一项，先输入多项式的指数，再输入多项式的系数，以0 0为结束标志，结束一个多项式的输入。

输入形式：2 3-1 23 01 20 0输入值的范围：系数为int型，指数为float型（3）输出的形式：第一行输出多项式1；第二行输出多项式2；第三行输出多项式1与多项式2相加的结果多项式；第四行输出多项式1与多项式2相减的结果多项式；第五行输出多项式1与多项式2相乘的结果多项式二、概要设计程序实现a. 功能：将要进行运算的二项式输入输出；b. 数据流入：要输入的二项式的系数与指数；c. 数据流出：合并同类项后的二项式；d. 程序流程图：二项式输入流程图；e. 测试要点：输入的二项式是否正确，若输入错误则重新输入。

流程图：三、详细设计（1）：存储结构一元多项式的表示在计算机内可以用链表来表示，为了节省存储空间，只存储多项式中系数非零的项。

链表中的每一个结点存放多项式的一个系数非零项，它包含三个域，分别存放该项的系数、指数以及指向下一个多项式项结点的指针。

项目一一元多项式的计算问题1.1设计题目与要求1.1.1设计题目1）一元多项式计算任务：能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减，并将结果输入；基本要求：在上交资料中请写明：存储结构、多项式相加的基本过程的算法（可以使用程序流程图）、源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法；本程序关键点是如何将输入的两个多项式相加、相减操作。

①如何将输入的一元多项式按指数的降序排列②如何确定要输入的多项式的项数；③如何将输入的两个一元多项式显示出来。

④如何将输入的两个一元多项式进行相加操作。

⑤如何将输入的两个一元多项式进行相减操作。

本程序是通过链表实现一元多项式的相加减操作。

1.1.2、任务定义此程序需要完成如下的要求：将多项式按照指数降序排列建立并输出，将两个一元多项式进行相加、相减操作，并将结果输入。

a：输入多项式的项数并建立多项式；b：输出多项式，输出形式分别为浮点和整数序列，序列按指数升序排列；c：多项式a和b相加，建立多项式a+b；d：多项式a和b相减，建立多项式a-b。

e：多项式的输出。

1.2 数据结构的选择和概要设计：1.2.1数据结构的选用A:基于链表中的节点可以动态生成的特点，以及链表可以灵活的添加或删除节点的数据结构，为了实现任意多项式的加法，减法，因此选择单链表的结构体，它有一个系数，指数，下一个指针3个元属；例如，图1中的两个线性链表分别表示一元多项式和一元多项式。

从图中可见，每个结点表示多项式中的一项。

图1 多项式表的单链存储结构B：本设计使用了以下数据结构：typedef struct node{int xs; /*系数*/int zs; /*指数*/struct node * next; /*next指针*/}Dnode,* Dnodelist;C：设计本程序需用到八个模块，用到以下八个子函数如下：1.Dnodelist Creat_node(void) /*链表初始化*/2.int Insert_node(Dnodelist D,int xs,int zs) /*插入函数*/3.Dnodelist Creat_Dmeth(int length) /*创建多项式*/4.Dnodelist Addresult(Dnodelist D1,Dnodelist D2) /*多项式相加*/5.Dnodelist Subresult(Dnodelist D1,Dnodelist D2) /*多项式相减*/6.Dnodelist select(Dnodelist D1,Dnodelist D2) /*选择函数*/7void Show(Dnodelist D) /*显示（输出）函数*/8void main()主程序模块调用链一元多项式的各种基本操作模块。

数据结构课程设计——一元多项式计算一、课程设计题目及要求二、设计思路和方法三、程序流程图四、程序代码及注释五、测试结果及分析六、结论七、参考文献本次课程设计的题目为“一元多项式计算”，要求设计一个程序，能够实现一元多项式的加、减、乘、求导和求值等操作。

在设计思路和方法上，我们采用了链表的数据结构来存储多项式，同时设计了相应的函数来实现各种操作。

程序的流程图如下所示：插入流程图）程序的代码及注释如下所示：插入代码及注释）在测试结果及分析方面，我们对程序进行了多组测试，并对其进行了详细的分析和比较。

结果表明，我们的程序能够正确地实现各种操作，并且具有较高的效率和稳定性。

综上所述，本次课程设计的目标已经得到了圆满地实现，我们对于所取得的成果感到非常满意。

同时，我们也希望能够通过这次课程设计，加深对于数据结构及其应用的理解和掌握，为今后的研究和工作打下坚实的基础。

设计目标：本课程设计旨在结合理论与实际应用，提高学生组织数据及编写大型程序的能力。

通过掌握数据组织、算法设计和算法性能分析的方法，培养学生良好的程序设计能力。

具体实现是利用单链表表示一元多项式，实现多项式的输入、建立、输出、相加、相减和相乘。

总体设计：2.1 数据结构描述与定义：一元多项式定义系数和指数结构如下：coef，expn和next。

定义多项式的结构为线性链表的存储结构，每个结点包含三个元素：系数coef，指数expn和指向下一个结点的指针*next。

多个单项式通过指针连接起来，形成一个多项式。

2.2 模块设计：从实现多项式运算过程的角度来分析，至少需要以下子功能模块：多项式创建、销毁、输出、相加、相减和相乘。

定义并调用的函数有：Insert、CreatePolyn、DestroyPolyn、PrintPolyn、AddPolyn、SubtractPolyn、XXX和main函数。

注：该文章中没有明显的格式错误和需要删除的段落，因此没有进行小幅度改写。

数据结构上机实习报告实验题目：一元多项式班级：193121姓名：邹冠宏学号：20121002758指导老师：郭艳完成日期：2013/9/30一问题分析1. 问题描述设计一个n元多项式程序，并完成多项式的加法，乘法运算。

从实际的角度出发，这里设计的程序是基于一元n次多项式的数学模型。

2、功能需求1)构造一个空的多项式。

2)多项式插入新的一项。

3）计算多项式的值。

4）打印多项式。

5）多项式合并同类项。

6）多项式加法。

7）多项式乘法。

8)多项式减法二、概要设计1问题分析在数学上，一个一元多项式Pn(x)可按升幂写成：Pn(x)=a 0+a1 x+a2 x^2 +…+an x^n-1 .它由n+1个系数惟一确定，因此，在计算机里，它可用一个线性表P来表示：Pn=(a0,a1,a2,…,an)每一项的指数i隐含在其系数ai的序号里。

2数据模型设计一个单链表模型，动态分配空间，刻意随时插入新的一项多项式加法规则：两个具有相同指数的项合并，系数为0时把这一项省去，也就是删除了这一节点。

多项式的乘法规则：多次运用单项式与多项式相乘的法则得到的．计算时(a+b)(c+d)，把(c+d)看成一个单项式，(a+b) 是一个多项式，运用单项式与多项式相乘的法则，得到(a+b)(c+d)=a(c+d)+b(c+d),然后再次运用单项式与多项式相乘的法则。

3 构造数据结构通过分析多项式的特征，不难看出多项式是由单项式构成的，而每个单项式都具有系数和指数，当系数为0时，该项就失去了意义，在计算机内要表示一个多项式，至少以下数据信息：系数信息、指数信息和指向下一个单项式的指针。

通过指针，我们就可以把多个单项式连接起来，形式一个多项式，基于以上的分析，我们定义多项式的数据结构为如下结构体形式：typedef struct Polynomial{float coef;//系数int expn;//指数struct Polynomial *next;//指向下一个结点}*Polyn,Polynomial; //Polyn为结点指针类型三、详细设计1一元多项式运算程序具有以下基本功能：1）．界面输出，提示如何输入数据。

数据结构一元多项式的运算第一章引言在计算机科学中，数据结构是研究非原子数据对象的组织、存储和管理的科学和技术。

一元多项式是代数中的基本概念之一，它在计算机科学中有着广泛的应用。

本文将介绍一元多项式的运算，包括多项式的表示、加法、减法、乘法等操作。

第二章多项式的表示1.稀疏数组表示法稀疏数组表示法是一种常用的多项式表示方法。

它通过一个数组来存储多项式中非零项的指数和系数。

数组的下标表示项的指数，数组元素表示项的系数。

对于没有出现的指数，数组元素为零。

2.链表表示法链表表示法是另一种常用的多项式表示方法。

每个节点包含项的指数和系数，并通过指针串接成链表。

链表的节点可以按照指数的升序或降序排列。

第三章多项式的加法多项式的加法是指将两个多项式相加得到一个新的多项式。

具体操作如下：1.根据多项式的表示方法，分别遍历两个多项式的非零项。

2.比较当前项的指数大小，如果两个指数相等，则将系数相加得到新的系数，并将结果加入结果多项式中。

3.如果一个多项式的指数大于另一个多项式的指数，则将该项加入结果多项式中。

4.重复以上操作，直到遍历完所有的非零项。

第四章多项式的减法多项式的减法是指将两个多项式相减得到一个新的多项式。

具体操作如下：1.根据多项式的表示方法，分别遍历被减数和减数的非零项。

2.比较当前项的指数大小，如果两个指数相等，则将被减数的系数减去减数的系数得到新的系数，并将结果加入结果多项式中。

3.如果被减数的指数大于减数的指数，则将该项加入结果多项式中，并将被减数的系数变为相反数。

4.重复以上操作，直到遍历完所有的非零项。

第五章多项式的乘法多项式的乘法是指将两个多项式相乘得到一个新的多项式。

具体操作如下：1.创建一个结果多项式，将其初始化为零多项式。

2.根据多项式的表示方法，分别遍历两个多项式的非零项。

3.将两个项的系数相乘得到新的系数，并将两个项的指数相加得到新的指数。

4.将新的系数和指数合并为一个项，并将该项加入结果多项式中。

数据结构上机实习报告实验题目：实现一元多项式抽象数据类型班级：姓名：学号：指导老师：完成日期：1、需求分析1.1问题描述和规格说明已知一元n次多项式：设计程序实现一元n次多项式的抽象数据类型，模拟一元n次多项式的操作行为。

包括：数据元素：a i，存储结构，逻辑操作：1、构造一个空的多项式2、多项式插入新的一项3、多项式合并同类项4、多项式的加法P n(x)+Q n(x)=R t(x)5、多项式的乘法P n(x)*Q n(x)=R t(x)6、打印多项式7、计算多项式的值1.2功能需求1)首先构造两三个多项式供用户使用；2)用户可以进行添加多项式或是添加多项式中的项；3)或是修改其中的项，或是对多项式进行删除，或仅仅删除其中的某项；4)或是查看当前的某项多项式5) 用户赋予多项式变量x值后可以计算多项式的值6)可以计算两个或是多个多项式的和；7)可以计算两个以上多项式的乘积8)可以对多项式中的同类项进行合并2、设计(目标：有效组织与处理数据)2.1抽象数据类型:因为每个多项式有n个项，每个项包含不同的系数和指数，多项式的系数a i抽象为整数，变量x也是整数，x的次幂n也是整数，故多项式的每一项抽象为一个Nape类型的节点，包括：a i、x、n数据元素，最后整个一元n次多项式抽象为Polynomial数据类型。

详细设计如下：Nope类型设计为：class Nope{friend class Polynomial; //设置Polynomial为Nope的友元类，方便Polynomial类访问Nope的私有数据成员private:int m_factor; //项系数int m_times; //次幂public:Nope(int factor=0,int times=0);//构造函数~Nope();int GetFoctor()const; //获取项系数int GetTimes()const; //获取次幂void SetFactor(int factor); //设置项系数void SetTimes(int times); //设置次幂Nope & operator=(const Nope& item); //赋值=int operator<=(const Nope& item); //比较<=//比较次幂的大小friend ostream &operator<<(ostream& out, const Nope&item); //输出<<Nope(const Nope& item); //复制构造&};Polynoomial数据类型设计为：class Polynomial{private:int m_x; //多项式中的变量xint m_size; //多项式的项数LinListWithRear< Nope > m_list; //存储多项式的带尾指针的单向链表public:Polynomial(int size = 0,int factor= 1);//可以构造系数为factor，个数为size 的多项式，次幂依次增长~Polynomial();Polynomial(const Polynomial&poly);int GetM_size()const; //获取多项式的项数int GetM_x()const;int GetM_factor(const int& index)const; //获取第index项的系数//从第1项开始（而不是第0项）int GetM_times(const int& index)const; //获取第index项的次幂inline double GetM_Number(const int& index)const; //获取第index项的值,因为计算多项式的值时频繁调用，所以设计为内联函数int Getfactor(const int& times)const; //获取次幂为times的项的系数 //失败或没有，返回0int GetIndex(const int& times)const; //获取次幂为times 的项的下标//从1开始double GetNumber(const int& times)const; //获取次幂为times的项的值 //失败或没有返回0double GetTotalNumber()const; //获取整个多项式的值int SetM_factor(const int& index,const int& factor); //设置第index项的系数//从第1项开始（而不是第0项）int Setfactor(const int& times,const int& factor); //设置次幂为times 的项的系数//失败返回0int SetM_times(const int& index, const int& times); //设置次幂为times 的项的系数//失败返回0int SetM_x(const int & x); //给未知数m_x赋值bool DeleteIndex(const int & index); //删除第index项bool DeleteTimes(const int & times); //删除次幂为times的项bool DeleteFactor(const int& factor); //删除所有系数为factor的项inline int InsertEnd(const int& factor, const int& times); //从尾部插入新项，系数为factor，次数为times//失败返回0inline void InsertEnd(const Nope& item);Polynomial& operator=(const Polynomial&Poly); //赋值void Combine(); //合并同类项且按次幂排序void Print()const; //打印多项式void OrderPolynomial(); //按次幂排序多项式int OrderInsert(const int& factor, const int& times); //有序插入新项，系数为factor，次数为times//失败返回0Polynomial operator+(const Polynomial&polyb); //多项式的加法Polynomial operator*(const Polynomial&polyb); //多项式的乘法friend ostream &operator<<(ostream& out, const Polynomial& item);//输出<<};2.2存储结构设计：1)存储结构的确定数据结构的目的是有效组织和处理数据。

数据结构一元多项式的运算数据结构一元多项式的运算简介一元多项式是数学中常见的概念，用于表示一个变量的多项式表达式。

在计算机科学中，经常需要对一元多项式进行各种运算，如加法、减法、乘法等。

为了实现这些运算，可以使用数据结构来存储和操作一元多项式。

本文将介绍一元多项式的数据结构和常见的运算方法，并给出相应的代码示例。

数据结构一元多项式可以用链表来表示。

每个节点包含两个部分：系数（coefficient）和指数（exponent）。

系数表示该项的权重，指数表示该项的幂次。

链表的每个节点按照指数的升序排列。

以下是一个一元多项式的链表表示的示例：```markdown1.2x^2 + 3.7x^4 - 0.5x^3 -2.1x^1 + 4.0``````markdownNode 1: coefficient=1.2, exponent=2Node 2: coefficient=3.7, exponent=4Node 3: coefficient=-0.5, exponent=3Node 4: coefficient=-2.1, exponent=1Node 5: coefficient=4.0, exponent=0```运算方法加法运算两个一元多项式相加可以按照如下步骤进行：1. 遍历两个链表的节点，分别取出当前节点的系数和指数。

2. 如果两个节点的指数相等，将系数相加，并将其作为结果链表的节点。

3. 如果两个节点的指数不相等，将指数较小的节点插入结果链表，并继续遍历指数较大的节点。

4. 当其中一个链表遍历完后，直接将另一个链表的节点插入结果链表。

以下是加法运算的代码示例：```pythondef addPolynomials(p1, p2):result = Nonetl = Nonewhile p1 is not None and p2 is not None:if p1.exponent == p2.exponent:coef_sum = p1.coefficient + p2.coefficient if coef_sum != 0:node = Node(coef_sum, p1.exponent)if result is None:result = tl = nodeelse:tl.next = nodetl = nodep1 = p1.nextp2 = p2.nextelif p1.exponent > p2.exponent:node = Node(p1.coefficient, p1.exponent) if result is None:result = tl = nodeelse:tl.next = nodetl = nodep1 = p1.nextelse:node = Node(p2.coefficient, p2.exponent) if result is None:result = tl = nodeelse:tl.next = nodetl = nodep2 = p2.nextwhile p1 is not None:node = Node(p1.coefficient, p1.exponent)if result is None:result = tl = nodeelse:tl.next = nodetl = nodep1 = p1.nextwhile p2 is not None:node = Node(p2.coefficient, p2.exponent) if result is None:result = tl = nodeelse:tl.next = nodetl = nodep2 = p2.nextreturn result```减法运算减法运算可以看作加法运算的特殊情况，即将第二个多项式的系数取负数，再进行加法运算。

实验一线性表1 实验目的通过选择下面四个题目之一进行实现，掌握如下内容：熟悉C++语言的基本编程方法，掌握集成编译环境的调试方法学习指针、模板类、异常处理的使用掌握线性表的操作的实现方法学习使用线性表解决实际问题的能力2 实验内容2.1题目1根据线性表的抽象数据类型的定义，选择下面任一种链式结构实现线性表，并完成线性表的基本功能。

线性表存储结构（五选一）：1、带头结点的单链表2、不带头结点的单链表3、循环链表4、双链表5、静态链表线性表的基本功能：1、构造：使用头插法、尾插法两种方法2、插入：要求建立的链表按照关键字从小到大有序3、删除4、查找5、获取链表长度6、销毁7、其他：可自行定义编写测试main()函数测试线性表的正确性。

2.2题目2利用线性表实现一个通讯录管理，通信录的数据格式如下：struct DataType{int ID; //编号char name[10]; //姓名char ch; //性别char phone[13]; //电话char addr[31]; //地址};要求：实现通讯录的建立、增加、删除、修改、查询等功能能够实现简单的菜单交互，即可以根据用户输入的命令，选择不同的操作。

能够保存每次更新的数据（选作）能够进行通讯录分类，比如班级类、好友类、黑名单等等（选作）编写测试main()函数测试线性表的正确性2.3题目3利用线性表实现一个一元多项式Polynomialf(x) = a+ a1x + a2x2 + a3x3+ … + a n x n提示：Polynomial的结点结构如下：struct term{float coef; //系数int expn; //指数};可以使用链表实现，也可以使用顺序表实现。

要求：能够实现一元多项式的输入和输出能够进行一元多项式相加能够进行一元多项式相减能够计算一元多项式在x处的值能够计算一元多项式的导数（选作）能够进行一元多项式相乘（选作）编写测试main()函数测试线性表的正确性2.4题目4利用循环链表实现约瑟夫问题的求解。

数据结构一元多项式的运算在计算机科学和数学领域中，数据结构一元多项式的运算具有重要的地位。

一元多项式是指形如＄P(x) ＝ a_n x^n ＋ a_{n-1} x^｛n-1} ＋＼cdots ＋ a_1 x ＋ a_0$ 的表达式，其中＄a_i$ 是系数，＄x$ 是变量，＄n$ 是多项式的次数。

要有效地处理一元多项式，需要选择合适的数据结构来存储它们，并设计相应的算法来进行各种运算，如加法、减法、乘法和除法等。

常见的数据结构用于表示一元多项式有两种：顺序存储结构和链式存储结构。

顺序存储结构通常使用数组来存储多项式的系数。

可以将系数按照多项式的次数从高到低依次存放在数组的相应位置。

这种方式简单直观，但存在一些局限性。

例如，如果多项式的次数很高，但大部分系数为零，会浪费大量的存储空间。

而且，对于多项式的插入和删除操作，效率也比较低。

相比之下，链式存储结构更加灵活。

每个节点可以存储一个系数和对应的指数，然后通过指针将这些节点连接起来。

这样可以有效地节省存储空间，并且对于多项式的动态修改操作更加方便。

接下来，让我们详细探讨一下一元多项式的加法运算。

假设我们有两个一元多项式＄P(x) ＝ 3x^3 ＋ 2x^2 5x ＋ 1$ 和＄Q(x) ＝ 2x^3 4x^2 ＋ 6x 3$ 。

要进行加法运算，我们需要将相同次数的项的系数相加。

首先，比较两个多项式的最高次数。

在这个例子中，都是 3 次。

然后，从高次项开始逐次相加。

对于 3 次项，系数分别为 3 和 2，相加得到 5，所以相加后的多项式的 3 次项系数为 5。

对于 2 次项，系数分别为 2 和－4，相加得到－2。

依此类推，最后得到相加后的多项式为＄5x^3 2x^2 ＋ x 2$ 。

在实现加法运算的算法时，需要考虑两个多项式的长度可能不同的情况。

可以使用两个指针分别遍历两个多项式，当其中一个指针到达末尾时，将另一个多项式剩余的项直接添加到结果多项式中。

一元多项式的计算一、 需求分析建立一元多项式并按照指数降序排列输出多项式，将一元多项式输入并存储在内存中，能够完成两个多项式的加减运算并输出结果。

二、 概要设计存储结构：一元多项式的表示在计算机内可以用链表来表示，为了节省存储空间，只存储多项式中系数非零的项。

链表中的每一个结点存放多项式的一个系数非零项，它包含三个域，分别存放该项的系数、指数以及指向下一个多项式项结点的指针。

创建一元多项式链表，对一元多项式的运算中会出现的各种可能情况进行分析，实现一元多项式的相加、相减操作。

基本算法： 1、输入输出（1）功能：将要进行运算的多项式输入输出。

（2）数据流入：要输入的多项式的系数与指数。

（3）数据流出：合并同类项后的多项式。

（4）程序流程图：多项式输入流程图如图1所示。

（5）测试要点：输入的多项式是否正确，若输入错误则重新输入开始 申请结点空间 输入多项式的项数输入多项式各项的系数 x, 指数 y输出已输入的多项式合并同类项结束否是是否输入正确图表 12、多项式的加法（1）功能：将两多项式相加。

（2）数据流入：输入函数。

（3）数据流出：多项式相加后的结果。

（4）程序流程图：多项式的加法流程图如图2所示。

（5）测试要点：两多项式是否为空，为空则提示重新输入，否则，进行运算。

图表 2开始 定义存储结果的空链 r 是否输出存储多项式的和的链r结束 是 否同指数项系数相加后存入r 直接把p 中各项存入r直接把q 中各项存入r存储多项式2的空链Q 是否为空 存储多项式1的空链P 是否为空合并同类项3、多项式的减法（1）功能：将两多项式相减。

（2）数据流入：调用输入函数。

（3）数据流出：多项式相减后的结果。

（4）程序流程图：多项式的减法流程图如图3所示。

（5）测试要点：两多项式是否为空，为空则提示重新输入，否则，进行运算。

开始定义存储结果的空链 r是否输出存储多项式的和的链r结束是 否同指数项系数相加后存入r把p 中各项系数改变符号后存入直接把q 中各项存入r存储多项式2的空链Q 是否为空 存储多项式1的空链P 是否为空 合并同类项图表 3三、详细设计#include<stdio.h>#include<malloc.h>typedef struct Polynomial{float coef;int expn;struct Polynomial *next;}*Polyn,Polynomial; //Polyn为结点指针类型void Insert(Polyn p,Polyn h){if(p->coef==0) free(p); //系数为0的话释放结点else{Polyn q1,q2;q1=h;q2=h->next;while(q2&&p->expn<q2->expn){ //查找插入位置q1=q2;q2=q2->next;}if(q2&&p->expn==q2->expn){ //将指数相同相合并q2->coef+=p->coef;free(p);if(!q2->coef){ //系数为0的话释放结点q1->next=q2->next;free(q2);}}else{ //指数为新时将结点插入p->next=q2;q1->next=p;}}}//InsertPolyn CreatePolyn(Polyn head,int m){//建立一个头指针为head、项数为m的一元多项式int i;Polyn p;p=head=(Polyn)malloc(sizeof(struct Polynomial));head->next=NULL;for(i=0;i<m;i++){p=(Polyn)malloc(sizeof(struct Polynomial));//建立新结点以接收数据printf("请输入第%d项的系数与指数:",i+1);scanf("%f %d",&p->coef,&p->expn);Insert(p,head); //调用Insert函数插入结点}return head;}//CreatePolynvoid DestroyPolyn(Polyn p){//销毁多项式pPolyn q1,q2;q1=p->next;q2=q1->next;while(q1->next){free(q1);q1=q2;//指针后移q2=q2->next;}}void PrintPolyn(Polyn P){Polyn q=P->next;int flag=1;//项数计数器if(!q) { //若多项式为空，输出0putchar('0');printf("\n");return;}while (q){if(q->coef>0&&flag!=1) putchar('+'); //系数大于0且不是第一项 if(q->coef!=1&&q->coef!=-1){//系数非1或-1的普通情况printf("%g",q->coef);if(q->expn==1) putchar('X');else if(q->expn) printf("X^%d",q->expn);}else{if(q->coef==1){if(!q->expn) putchar('1');else if(q->expn==1) putchar('X');else printf("X^%d",q->expn);}if(q->coef==-1){if(!q->expn) printf("-1");else if(q->expn==1) printf("-X");else printf("-X^%d",q->expn);}}q=q->next;flag++;}//whileprintf("\n");}//PrintPolynint compare(Polyn a,Polyn b){if(a&&b){if(!b||a->expn>b->expn) return 1;else if(!a||a->expn<b->expn) return -1;else return 0;}else if(!a&&b) return -1;//a多项式已空，但b多项式非空else return 1;//b多项式已空，但a多项式非空}//comparePolyn AddPolyn(Polyn pa,Polyn pb){//求解并建立多项式a+b，返回其头指针 Polyn qa=pa->next;Polyn qb=pb->next;Polyn headc,hc,qc;hc=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点hc->next=NULL;headc=hc;while(qa||qb){qc=(Polyn)malloc(sizeof(struct Polynomial));switch(compare(qa,qb)){case 1:{qc->coef=qa->coef;qc->expn=qa->expn;qa=qa->next;break;}case 0:{qc->coef=qa->coef+qb->coef;qc->expn=qa->expn;qa=qa->next;qb=qb->next;}case -1:{qc->coef=qb->coef;qc->expn=qb->expn;qb=qb->next;break;}}//switchif(qc->coef!=0){qc->next=hc->next;hc->next=qc;hc=qc;}else free(qc);//当相加系数为0时，释放该结点}//whilereturn headc;}//AddPolynPolyn SubtractPolyn(Polyn pa,Polyn pb){//求解并建立多项式a+b，返回其头指针 Polyn h=pb;Polyn p=pb->next;Polyn pd;while(p){ //将pb的系数取反p->coef*=-1;p=p->next;}pd=AddPolyn(pa,h);for(p=h->next;p;p=p->next) //恢复pb的系数p->coef*=-1;}//SubtractPolynint main(){int m,n,flag=0;float x;Polyn pa=0,pb=0,pc,pd,pe,pf;//定义各式的头指针，pa与pb在使用前付初值NULL printf("请输入a的项数:");scanf("%d",&m);pa=CreatePolyn(pa,m);//建立多项式aprintf("请输入b的项数:");scanf("%d",&n);pb=CreatePolyn(pb,n);//建立多项式a//输出菜单printf("**********************************************\n");printf("操作提示：\n\t1.输出多项式a和b\n\t2.建立多项式a+b\n\t3.建立多项式a-b\n");printf("\t4.退出\n**********************************************\n");for(;;flag=0){printf("执行操作：");scanf("%d",&flag);if(flag==1){printf("多项式a：");PrintPolyn(pa);printf("多项式b：");PrintPolyn(pb);continue;}if(flag==2){pc=AddPolyn(pa,pb);printf("多项式a+b：");PrintPolyn(pc);DestroyPolyn(pc);continue;}if(flag==3){pd=SubtractPolyn(pa,pb);printf("多项式a-b：");PrintPolyn(pd);DestroyPolyn(pd);continue;}if(flag==4) break;if(flag<1||flag>4) printf("Error!!!\n");continue;}//forDestroyPolyn(pa);DestroyPolyn(pb);return 0;}四、调试结果1.测试的数据及结果2.算法的时间复杂度及改进算法的时间复杂度：一元多项式的加法运算的时间复杂度为O(m+n）,减法运算的时间复杂度为O(m-n)，其中m，n分别表示二个一元多项式的项数。