多项式求和

合集下载

单链表应用之稀疏多项式求和（C语言）

单链表应⽤之稀疏多项式求和（C语⾔）采⽤归并思想计算两个多项幂式之和，这⾥有两个化简好的关于x的多项幂式：A(x)=7+3x+9x^8+5x^17+2x^20；B(x)=8x+22x^7-9x^8-4x^17，⽤C语⾔实现两多项式数据的存储，并求两者的和Y(x)。

之所以称之为稀疏多项式，是因为多项式中各项x的指数部分不连续，且相差较⼤，故编程实现该类多项式存储时可考虑链式存储，提升空间利⽤率。

完整代码如下：#include <stdio.h>#include <stdlib.h>/*** 含头节点单链表应⽤之稀疏多项式相加：* A(x)=7+3x+9x^8+5x^17+2x^20* B(x)=8x+22x^7-9x^8-4x^17* 求：Y(x)=A(x)+B(x)*///基本操作函数⽤到的状态码#define TRUE 1;#define FALSE 0;#define OK 1;#define ERROR 0;//Status是新定义的⼀种函数返回值类型，其值为int型typedef int Status;//数据元素类型typedef struct {int coe; //系数int exp; //指数} ElemType;//单链表定义typedef struct Lnode {ElemType data; //数据域struct Lnode *next; //指针域} Lnode, *LinkList;//基本操作1：单链表初始化Status InitList(LinkList *list) {(*list)=(LinkList)malloc(sizeof(Lnode));(*list)->next=NULL;return OK;}//基本操作11：头插法建⽴链表，数据已保存在ElemType类型的数组中Status CreateList_H(LinkList *list,ElemType arrData[],int length) {int j;for(j=length-1;j>=0;j--){//新建结点Lnode *node;node=(Lnode*)malloc(sizeof(Lnode));node->data=arrData[j];node->next=NULL;//插⼊为1号结点node->next=(*list)->next;(*list)->next=node;}return OK;}//基本操作13：链表元素遍历输出Status ListTraverse(LinkList list) {Lnode *p;p=list;int j=0;printf("序号：系数：指数：\n");while(p->next){j++;p=p->next;printf("(%d) %d %d\n",j,(p->data).coe,(p->data).exp);}printf("\n");return OK;}//多项式求和, pa、pb、pc分别指向listA、listB、合并后新链表的当前结点Status GetPolynthicSum(LinkList *listA,LinkList *listB){Lnode *pa,*pb,*pc;pa=(*listA)->next;pb=(*listB)->next;pc=(*listA);while(pa&&pb){if(pa->data.exp==pb->data.exp) {Lnode *waitInsert=pa;pa->data.coe+=pb->data.coe; //系数相加if(pa->data.coe==0) { //系数和为零pa=pa->next;free(waitInsert); //释放系数和为零的结点} else {pa=pa->next;//表尾加⼊新结点，并更新为该新结点pc->next=waitInsert;pc=pc->next;}Lnode *needDelete=pb;pb=pb->next;free(needDelete); //释放listB中的结点} else if(pa->data.exp<pb->data.exp) {Lnode *waitInsert=pa;pa=pa->next;//表尾加⼊新结点，并更新为该新结点pc->next=waitInsert;pc=pc->next;} else {Lnode *waitInsert=pb;pb=pb->next;//表尾加⼊新结点，并更新为该新结点pc->next=waitInsert;pc=pc->next;}}//连接剩余结点if(pa) { //表listA长于listBpc->next=pa;} else {pc->next=pb;}//释放list_B表头free(*listB);return OK;}int main(void){//产⽣多项式相关数据，A(x)、B(x)的项按幂增排列ElemType waitInserted_A[] = {{ 7, 0 },{ 3, 1 },{ 9, 8 },{ 5,17 },{ 2, 20 }};ElemType waitInserted_B[] = {{ 8, 1 },{ 22, 7 },{ -9, 8 },{ -4, 17 }};//获得数组长度int arrLength_A=sizeof(waitInserted_A)/sizeof(waitInserted_A[0]); int arrLength_B=sizeof(waitInserted_B)/sizeof(waitInserted_B[0]);//头插法建⽴链表list_A和list_B分别保存A(x)、B(x)两个多项式的数据 LinkList list_A,list_B;InitList(&list_A);InitList(&list_B);CreateList_H(&list_A,waitInserted_A,arrLength_A);CreateList_H(&list_B,waitInserted_B,arrLength_B);printf("多项式A(x)的数据：\n");ListTraverse(list_A); //遍历测试printf("多项式B(x)的数据：\n");ListTraverse(list_B); //遍历测试//计算Y(x)=A(x)+B(x)；结果数据放⼊list_A;GetPolynthicSum(&list_A,&list_B);printf("多项式Y(x)=A(x)+B(x)的数据：\n");ListTraverse(list_A); //遍历测试printf("\nEND!");return0; }。

一元多项式相加问题实验报告

一元多项式相加问题实验报告一元多项式相加问题一、问题描述通过键盘输入两个形如P 0 +P 1 X 1 +P 2 X 2 +…+P n X 的多项式，经过程序运后在屏幕上输出它们的相加和。

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

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

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

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

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

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

⑶初始化完成后将最后一个结点的指针域置为空，并返回该新建链表的首地址。

if(q!=NULL)q-next=NULL;return a; ⑷动态分配空间新建结点存储系数和指数的代码如下：p=new node;p-coef=x;p-exp=y;if(a==NULL) a=p;else q-next=p;q=p; 2、多项式显示功能函数由于系数有正有负，故采取如下处理：对于正数，输出时在前面加“+”，头指针除外；对于负数，直接将系数输出即可，即：p=a;while(p){if(p==a)coutp-coef"*x^"p-else if(p-coef0)coutp-coef"*x^"p-else if(p-coef0)cout"+"p-coef"*x^"p-p=p-next;} 输出的多项式的形式形如：P 1 X^1+P 2 X^2+…+P n X^n 3、多项式相加的功能函数函数为：node *plus_fun(node *a,node *b) 此函数根据在 1 中初始化的两个多项式进行相加运算，并存放在以c 为头指针的一个新链表中。

一类特殊多项式的求和问题

两边同乘ｚ后，对ｚ求导得：再
Ｓ：１＋２ｚ４３ｚ。 … ＋７ｚ４－－２＝：＝
ｃ一年１ｚ
（）当ｚ一１时，２有
— — — — —
（．ｒ兰一
一
一
．
［ｌｘ４ｌｘ＋ｚ一（１１ｌｌ。ｎ）ｚ＋－４－－４
当ｚ≠ １时，３由（）知
Ｓ一１＋２ｚ４３ｚ－ … ４ｎＸｒ。。４－－。，：－
Ｓ＝１＋３＋２＋…＋一￣ｎｎ）－（＋１．
当ｚ≠ １时，由于
＋５Ｃ２＋ｚ。 … ＋Ｘ＋ｎ一＿－一：ｌＸ．＋２：ｎ
ｓ－ｔ一１２３。 … ４～ｚｒ卜＋卜ｚ４卜３４－２－－，
两边同乘后，再对ｚ求导得：
Ｓ一１＋ ’ ＋３ｚ。２。＋ … ＋ｎ一＝Ｚ￣Ｚ１Ｘ一＋１。＋（＋２＋）２ｎ一１）
Ｃ（＋２１＋ … ＋）＋ … ＋
［Ｌｃ＋ … ＋ｃｃＩ＋３ｊ。抖～
证明
Ｃ（１＋２＋３＋ … ＋）＋。．
１＋Ｃ・ｌ＋ｃ・＋ＣＦ－ … ・１１＋，３抖一（２＋１抖一）
摘要利用二项式定理给出自然数幂和的求和公式，由此出发，用逐项求导法得到形如利
Ｓ（）＝１＋２ｘ＋３ｚ。＋ … ＋ｚｋ
的多项式和的算法．关键词多项式；和；导求求中图分类号Ｏ１３７文献标识码Ａ文章编号１０—３９２１）１０６ —２０８１９（０２０ —０５０

线性表——一元多项式的求和

线性表——⼀元多项式的求和♥注：未经博主同意，不得转载。

多项式的表⽰与求和是线性表应⽤的典型案列。

在数学上，⼀元多项式P（x）的表⽰为：P（x）=a0+a1x+a2x2+…+anxn其中，n为⼤于或等于0的整数，表⽰x的幂：a o,a1,…a n为系数，a n≠0,a0，a1，…，a n-1可以为0，也可以不为0。

⼀元多项式的表⽰为了表⽰⼀元多项式，可以将其所有项的系数⽤⼀个线性表来表⽰：（a0,a1,…，a n）。

这个线性表可以使⽤顺序存储结构或链式存储结构来存储，从⽽进⾏多项式的有关运算。

若采⽤顺序存储结构，可使⽤⼀个⼀维数组存储这个线性表，即多项式的系数，⽽相应的幂则使⽤数组下标来表⽰。

⼀元多项式的顺序存储结构如下：1 typedef int DataType;2const int MaxPolySize=100;34class Polyn5 {6private:7 DateType data[MaxPolySize];8int size; //元素的个数910public:11 Polyn(){size = 0;} //构造⼀个空多项式12 ~Polyn();1314void Clear(){size=0;} //清空15 Polyn sum(Polyn a); //多项式相加16 Polyn sub(Polyn a); //多项式相减17 }; 但多项式的顺序存储有⼀个缺点：当存储形如P(x)=1+10x99的多项式时，由于a1到a98均为0，所以⽤来存储⼀元多项式的⼀维数组中的绝⼤部分单元存储的值都是0，导致存储效率低下，造成存储空间的浪费。

因此，⼀般采⽤链式存储结构来描述⼀元多项式。

⼀元多项式的链式存储必须显式地表达系数值和幂值，这是由于链式存储打破了顺序存储中原有的幂与数组下标间的⼀⼀对应关系，⼀元多项式的项的结点结构表⽰如图所⽰。

⼀元多项式的链式存储结构表⽰如下：12struct term3 {4double coef; //系数5int expn; //指数6 };7struct PNode8 {9 term data;10 PNode *next;11 };12class Ployn13 {14 PNode *phead;15public:16 Polyn()17 { //构造函数18 phead =new PNoed;19if(phead= =NULL)20 exit(0);21 phead->next=NULL;22 }23 ~Polyn(); //析构函数2425void PolynAdd(Ployn Pa,Ployn Pb); //两个多项式相加26void Print(); //打印多项式27void Create(); //建⽴多项式28 };29⼀元多项式的求和本节以多项式的加法为例，讲述⼀元多项式操作的实现。

用不定积分解答多项式数列求和问题的措施

探索探索与与研研究究在习题训练时，我们经常会遇到数列求和问题，其中多项式数列求和问题属于难度较大的一类题目.由于解答此类问题过程中的运算量较大，因而很多同学经常得不到正确的答案.事实上，我们可以利用不定积分来解答多项式数列求和问题.仔细观察数列{}n 2的前n 项和公式与函数y =x 2的不定积分，可以发现二者之间存在很多相似之处：（1）都是三次式；（2）三次式最高次项的系数都为13.这给了我们一个启示：多项式数列的前n 项和公式与对应的多项式函数不定积分之间有很多相同的地方.观察∑i =1ni =n (n +1)2,∑i =1n i =n (n +1)()2n +16,∑i =1n i =éëêùûún (n +1)22，可发现多项式数列的特点，可以得到下面的定理.定理1：若f k (n )=∑i =1ni k,k ∈N,则f k (n )必含有因子n .证明：采用数学归纳法证明.①当k =0时，f 0(n )=n ,结论成立.②假设当k ≤m ,m ∈N 时，结论成立，那么k =m +1时,由(n +1)m +2-n m +2=C m +1m +2n m +1+C m m +2nm+⋯+C 2m +2n 2+C 1m +2n +1,得∑i =1n []()i +1m +2-im +2=∑i =1n (Cm +1m +2im +1+C m m +2i m +⋯+C 2m +2i2+C1m +2i +1，∴(n +1)m +2-1=(m +2)∑i =1n im +1+Cm m +2∑i =1nim +1+⋯+C2m +2⋅∑i =1ni2+C 1m +2∑i =1ni +n ，∴∑i =1n i m -1=1m +2⋅éëê(n +1)m +2-1-æèçC mm +2∑i =1ni m +⋯+C 2m +2⋅ùûúöø÷∑i =1ni 2+C 1m +2∑i =1ni +n (*)，右边显然含有因子n ,故左边也含有因子n .由①②得,f k (n )中必含有因子n .证毕.定理2：f k (n )=∑i =1ni k ,k ∈N +,则f ′k (n )=∑i =1n(i k )′+B k =k ⋅∑i =1n ik -1+B k ,其中B k 是常数.若B 0=1,则∑i =0nC i nB i =∑i =0nC i n B i=n +B n ,∑i =0nC i n(-1)n -iB i =B n ,n ∈N.证明：采用数学归纳法证明.当k =1时,f 1(n )=n 2+n 2,f ′k (n )=n +12,又∑i =1ni 0+B 1=n +B 1,所以B 1=12,结论成立.假设k ≤m ,m ∈N +时,结论成立，则当k =m +1时,在(*)式的两边同时对n 求导，得æèçöø÷∑i =1n i m +1′n =1m +2⋅éëê(n +1)m +2-1-æèçC m m -2∑i =1n i m +⋯+ùûúöø÷C 2m +2∑i =1ni 2+C 1m +2∑i =1ni +n ′n.可得æèçöø÷∑i =1n i m +1′n=(n +1)m +1-1m +2æèçC m m +2∑i =1n (i m )′+⋯+öø÷C2m +2∑i =1n (i 2)′+C 1m +2∑i =1n(i )′+C ，其中C =C m m +2B m +C m -1m +2B m -1+⋯+C 2m +2B 2+C 1m +2B 1+B 0,化简右边的式子得：æèçöø÷∑i =1n i m +1′=(m +1)∑i =1n i m +1-Cm +2.显然1-Cm +2是一个常数,记为B m +1.于是B m +1=1-Cm +2,即(m +2)B m +1=(m +2)-(C m m +2B m +⋯+C 2m +2B 2+C 1m +2⋅B 1+B 0)，⇔C m m +2B m +1+(C m m +2B m +⋯+C 2m +2B 2+C 1m +2B 1+B 0)=m +2，⇔C m +2m +2B m +2+C m +1m +2B m +1+(C m m +2B m +⋯+C 2m +2B 2+C 1m +2B 1+B 0)=B m +2+(m +2)，⇔∑i =0m +2C i m +2B i =(m +2)+B m +2,m ∈N +，(1)所以结论成立.证毕.通过证明可得∑i =0m +2(-1)m +2-i C im +2B i =B m +2,m ∈N +，(2)令B 0=1,B 1=12,B k =B k，那么(1)（2）式就变为:ìíî(B +1)n =B n +n ，(B -1)n=B n (n ≠1)，n ∈N +，令n =2k ,k ≥2,得ìíîïï(B +1)2k =C 2k 2k B 2k +C 2k -12k B 2k -1+⋯+C 22kB 2+C 12kB 1+B 0=B 2k+2k ，(B -1)2k=C 2k 2kB 2k-C 2k -12kB 2k -1+⋯+C 22kB 2-C 12kB 1+B 0=B 2k，将两式相减得,2C 2k -12k B 2k -1+2C 2k -32k B 2k -3+⋯+C 32k B 3+2C 12k B 1=2k ,53探索探索与与研研究究又B 1=12,所以2C 2k -12k B 2k -1+2C 2k -32k B 2k -3+⋯+2C 32k B 3=0，依次令k =2,3,4,⋯,得B 3=B 5=B 7=⋯=0.可得数列{B k }前几项为:B 0=1,B 1=12,B 2=16,B 3=0,B 4=-130,B 5=0,B 6=142,⋯,数列{B k }就是伯努利数列,对应的递推公式为(B +1)n =B n (n ≠1),(B -1)n =B n +(-1)n n ,n ∈N .通过进一步研究,就可以得到公式∑i =1ni k =1k +1⋅[(B +n )k +1-B k +1].该式为1713年雅格布·伯努力著的《猜度术》中的方幂和公式.定理3：g (n )是多项式,f (n )=∑i =1n g (i ),则ìíîïïïïf ′(n )=∑i =1ng ′(i )+f ′(0)，f (1)=g (1)，f (0)=0,证明:由定理1得,∑i =1n g (i )中必含有因子n ,所以f (0)=0.而f (1)=g (1),由定理2得f ′(n )=∑i =1n g ′(i )+C .由定理1得∑i =1ng ′(i )中必含有因子n ,所以当n =0时,f ′(0)=0+C .所以f ′(n )=∑i =1n g ′(i )+f ′(0)，证毕.推论1：g (n )是多项式,f (n )=∑i =1n g (i ),则一定有ìíîïïïïïïïïf ″(n )=∑i =1ng ″(i )+f ″(0)，f ′(1)-f ′(0)=g ′(1)，f (1)=g (1)，f (0)=0.推论2：g (n )是多项式,f (n )=∑i =1n g (i ),则一定有ìíîïïïïïïïïïïïïïïïïïïïïf (k )(n )=∑i =1ng (k )(i )+f (k )(0)，f (k -1)(1)-f (k -1)(0)=g (k -1)(1)，f (k -2)(1)-f (k -2)(0)=g (k -2)(1)，⋯f ″(1)-f ″(0)=g ″(1)，f ′(1)-f ′(0)=g ′(1)，f (1)=g (1)，f (0)=0.这里运用导数的运算性质、不定积分公式、数学归纳法以及组合知识得到了伯努利数的递推公式,并通过进一步研究得到了方幂和的通项公式.由定理3、推论1、推论2可知，求高次多项式数列的和,要先对数列通项公式求导,再求和，最后用不定积分公式∫x k d x =1k +1x k +1+C,解微分方程就可以得到f (n )了.例题：(2020全国文数卷I,第16题)数列{a n }满足a n +2+(-1)n a n =3n -1,前16项和为540,则a 1=_____.解：令n =2k -1,k ∈N +,得a 2k +1-a 2k -1=6k -4,a 2k +1=(a 2k -1-a 2k -3)+(a 2k -3-a 2k -5)+⋯+(a 3-a 1)+a 1=(6k -10)+(6k -16)+⋯+2+a 1=(6k -10+2)(k -1)2+a 1=3k 2-7k +4+a 1，令h (k )=∑i =1ka 2i -1=∑i =1k(3i 2-7i +4+a 1),∴h (k )必含有因子k ,且有h ′(k )=∑i =1k(3i 2-7i +4+a 1)′+h ′(0)=∑i =1k(6i -7)+h ′(0)=3k 2-4k +h ′(0)，∴h (k )=∫[3k 2-4k +h ′(0)]d x =k 3-2k 2+h ′(0)k .令n =2k ,k ∈N +,得a 2k +2+a 2k =6k -1,即a 2k +2-3(k +1)+2=-(a 2k -3k +2).∴a 2k -3k +2=(a 2-1)(-1)k -1，∴∑i =1ka 2i =∑i =1k[3i -2+(a 2-1)(-1)i -1]=(3k -1)k 2+(a 2-1)⋅1-(-1)k2.∑i =116a i=∑i =18a2i -1+∑i =18a 2i =h (8)+23×82=540,即83-2×82+h ′(0)⋅8+23×82=540，∴h ′(0)=8,∴h (k )=k 3-2k 2+8k ,∴a 1=h (1)=7解答本题，需根据定理1、定理2得到∑i =1ka 2i -1=k 3-2k 2+h ′(0)k 的表达式，这是是解答本题的关键.然后根据定理3、推论2，通过求不定积分得到h (k )的表达式，进而求得a 1的值.运用不定积分求高次多项式数列的和，关键要建立数列的前n 项和与多项式函数不定积分之间的联系，根据上述3个定理得出多项式函数f (n )=∑i =1ng (i )，然后通过求不定积分，求得数列的前n 项和.（作者单位：江西省赣州市南康区第三中学）54。

c++一元多项式求和顺序表类

c++一元多项式求和顺序表类以下是一个简单的C++ 代码示例，演示了如何使用顺序表类来实现一元多项式的求和。

```cpp#include <iostream>#include <vector>// 顺序表类template <typename T>class SequenceList {public:SequenceList(int size) : maxSize(size), length(0) {data = new T[maxSize];}~SequenceList() {delete[] data;}void insert(T value) {if (length < maxSize) {data[length] = value;length++;}}T& operator[](int index) {return data[index];}int size() {return length;}private:T* data;int maxSize;int length;};// 一元多项式类class Polynomial {public:Polynomial() {}void addTerm(int coefficient, int exponent) {coefficients.insert(coefficient);exponents.insert(exponent);}int evaluate(int x) {int result = 0;for (int i = 0; i < coefficients.size(); i++) {result += coefficients[i] * pow(x, exponents[i]);}return result;}private:SequenceList<int> coefficients;SequenceList<int> exponents;};int main() {Polynomial p;p.addTerm(3, 2); // 3x^2p.addTerm(2, 1); // 2xp.addTerm(5, 0); // 5std::cout << "Result: " << p.evaluate(2) << std::endl; // Evaluate the polynomial at x=2return 0;}```在这个示例中，我们首先定义了一个顺序表类`SequenceList`，然后定义了一个一元多项式类`Polynomial`。

多项式求和顺序储存结构

#include<stdio.h>#define MAXLEN 100typedef struct{int data[MAXLEN];int last;}SeqList;void create_list(SeqList *D){ int n,i;printf("请按多项式X的最高次数：");scanf("%d",&n);for(i=MAXLEN-1;i>=0;i--)D->data[i]=0;printf("请输入多项式X的系数，缺少该项请输入0:\n");for(i=n;i>=0;i--){ printf("输入X^%d项的系数: ",i);scanf("%d",&D->data[i]);}D->last=n;}void add_List(SeqList A, SeqList B, SeqList *C){ int i;C->last=st>st? st:st;for(i=0;i<=C->last;i++)C->data[i]=A.data[i]+B.data[i];}void Show(SeqList C){int i,n=1; //项数计数for(i=st;i>=0;i--){if(C.data[i]==0) continue;if(C.data[i]>0&&n!=1) putchar('+');if(C.data[i]!=1&&C.data[i]!=-1){printf("%d",C.data[i]);if(i==1) putchar('X');else if(i) printf("X^%d",i);}else{if(C.data[i]==1){if(!i) putchar('1');else if(i==1) putchar('X');else printf("X^%d",i);}if(C.data[i]==-1){if(!i) printf("-1");else if(i==1) printf("-X");else printf("-X^%d",i);}}n++;}printf("\n");}void main(){ SeqList A,B,C;printf("生成多项式f(X):\n");create_list(&A);printf("f(X)=");Show(A);printf("生成多项式g(X):\n");create_list(&B);printf("g(X)=");Show(B);printf("多项式f(X)和g(X)的和\n ");add_List (A,B,&C);printf("f(X)+g(X)=");Show(C);}。

两多项式求和（C语言版）

两多项式求和（C语言版）#include "stdlib.h"#include "stdio.h"# define OVERFLOW -2typedef struct term{ float coef; //多项式系数int expn; //多项式指数struct term *next;} node;node *Create(int n)//创建一个n个结点的链表，并给每//个节点数据域赋值{ node *head, *p, *q;//int i;head=(node *)malloc(sizeof(node));if(!head) { printf("分配内存失败!");exit(OVERFLOW);}for(i=0;i<n;i++)< p="">{ p=(node *)malloc(sizeof(node));if(!p){ printf("分配内存失败!");exit(OVERFLOW);}printf("请输入第%d项系数：\n",i+1);//从键盘读取数据scanf("%f",&p->coef);printf("请输入第%d项指数：\n",i+1);scanf("%d",&p->expn);//从键盘读取数据if(i==0)//如果是第一个节点，则指针q、head同时指向该第一个实节点head->next=q=p;else //否则一个节点一个节点往后接{ q->next=p;p->next=NULL;q=p;}}return(head);//返回所建链表头指针}int cmp (node *m,node *n )//比较两个指数大小，并返回-1或0或1 { if(m->expnexpn)return -1;else if(m->expn==n->expn)return 0;elsereturn 1;}float Sum(node *m,node *n)//求多项式两个系数之和{ return m->coef+n->coef;}node *Add (node *a,node *b )//两个多项式相加{ node *ha,*hb,*pa,*pb,*tmpb;int t;ha=a;hb=b;while(ha->next!=NULL) {pa=ha->next;pb=hb->next;tmpb=hb;while(tmpb->next!=NULL){t=cmp(pa,pb);if(t==0){ (pa->coef)+=(pb->coef);pb=pb->next;tmpb->next=pb;}if(t!=0){tmpb=pb;pb=pb->next;}}ha=ha->next;}if(hb->next!=NULL)//如果多项式b还有某些项未执行相加操作，//则将其接到结果多项式a后面ha->next=hb->next;return a;//返回结果多项式}int main(){ node *x,*y,*p,*hp;int m=0,n=0;char c1,c2;printf("请输入第一个多项式的项数!\n");scanf("%d",&m);printf("请输入第一个多项式\n\n");x=Create(m);printf("请输入第二个多项式的项数!\n");scanf("%d",&n);printf("请输入第二个多项式\n\n");y=Create(n);p=Add(x,y );printf("两个多项式相加成功，其结果如下:\n"); while(p->next!=NULL)//输出相加所得的多项式{ printf("%5.1f",p->next->coef);if(p->next->expn!=0)printf(" * X(%d)",p->next->expn);p=p->next;if(p->next!=NULL)printf(" + ");}c1=getchar();c2=getchar();if(c2=='\n')printf("\n");return 0;}</n;i++)<>。

数据结构多项式相加实验报告doc

数据结构多项式相加实验报告篇一：数据结构实验多项式加法数据结构实验报告实验名称：多项式加减法学号：1XX10419姓名：林强实验日期：XX.5.05一、实验目的通过实现多项式的加减法，对链表有更深入的了解二、实验具体内容1、实验题目1：（1）题目设计一个一元稀疏多项式简单的加减法计算器实现要求：一元稀疏多项式简单计算器的基本功能是：（1）输入并建立多项式：A(x)?7?3x?9x8?5x17；B(x)?8x?22x7?9x8（2）输出多项式（3）多项式A和B相加，建立多项式C＝A＋B，并输出相加的结果多项式C（4）选作：多项式A和B相减，建立多项式C＝A－B，并输出相加的结果多项式D（2）分析1：本程序的任务是实现两个多项式的加法其中多项式的系数为浮点型，指数为整数，输出的结果也为系数和指数。

（1）输入的形式和输入值的范围：输入多项式的系数a和未知数X的指数b，当a和b都为零时，输入结束。

输入值的范围：a为实数，b为整数。

（2）输出形式：输出多项式的系数和多项式未知数X 的指数即(a,b)形式。

（3）程序所能达到的功能，实现两个多项式的加法，并输出最后的结果2：整个程序运行期间实行动态创建节点，一边输入数据，一边创建节点当将全部数据输入到单链表中后再调用多项式加法这个函数，并一边实现多项式的相加，一边释放节点，有效防止了在程序反复运行过程中可能出现系统空间不够分配的现象（3）实验代码typedef int Status;#define OVERFLOW -1#define null 0typedef struct Lnode{float coef; //存储项系数int expn;//存储项指数struct Lnode *next;}Lnode,*LinkList;typedef LinkList polynomial;Status InitList_L(LinkList &L) {//初始化头节点L=(LinkList)malloc(sizeof(Lnode));if(!L)return(-1);L->next=null;return 1;}void AddPolyn(polynomial pa, polynomial pb){ //实现两个多项式相加的算法float x;polynomial qa;polynomial qb;polynomial s;polynomial u;qa=pa->next; qb=pb->next; s=pa;while(qa&&qb){if(qa->expnexpn){s=qa;qa=qa->next;}else if(qa->expn==qb->expn){x=qa->coef+qb->coef;if(x!=0){qa->coef=x;s=qa;qa=qa->next;u=qb;qb=qb->next;free(u);}else{s->next=qa->next;free(qa);qa=s->next;u=qb;qb=qb->next;free(u);}}else if(qa->expn>qb->expn){ u=qb->next;s->next=qb;s=qb;qb->next=qa;qb=u;}}if(qb)qa->next=qb;free(pb);}void main(){float a;int b;polynomial L1;polynomial L2; LinkList q;LinkList p;LinkList m;LinkList n;InitList_L(L1);q=L1;InitList_L(L2);p=L2;cout 请输入数据：" for(;;){ cin>>a;cin>>b;if(a==0&&b==0) break;m=new Lnode;m->coef=a;m->expn=b;q->next=m;q=m;q->next=null;}//循环输入第一个多项式的系数与指数for(;;){cin>>a;cin>>b;if(a==0&&b==0)break;n=new Lnode;n->coef=a;n->expn=b;p->next=n;p=n;p->next=null;}//循环输入第二个多项式的系数与指数AddPolyn(L1,L2);//调用多项式相加的算法while((L1->next)!=null){coutnext->coefnext->expn L1=L1->next;}//输出计算结果}三、实验小结通过编写多项加法这个程序，我将自己所学到的创建链表，初始化链表和多项式加法算法都应用了一次，这使我们不仅仅只是理论化的学习书本上的知识，而是将学习到的理论知识应用到实际的操作中来增强我们的实际操作能力，这使我增加了实际操作经验，也使我通过实际操作来认识到自己在程序编写上的不足从而增强了我的实际编写程序的能力。

两个多项式求和

程序设计实践（大作业）两个多项式求和问题描述：通常在数学中对一元n次多项式可表示成如下形式：给定一个多项式，在C语言中可以用可读的形式将该多项式规范地输出。

例如，给出系数1 5 22 4 33 3 1 1 -1 0，输出为x^5+22x^4+33x^3+x-1。

所使用的规则如下：（1）多项式各项按照指数的递减顺序输出（2）次数出现在^之后，如3x^2（3）常数项仅输出常数。

（4）如果所有的项都是以0作为系数，则仅输出常数0，否则输出非零系数的项。

（5）如果第1项的系数是正数，在该项前没有符号；如果第1项的系数是负数，在该项前是减号，如2x^4+3x^2-10，-2x^4+3x^2-10。

（6）非常数项系数为1和-1不用显示，如x^7-10x^2，-x^2-x+2。

对每一项输入系数和指数。

按指数从高到低的顺序输入。

系数和指数的大小都在【-100，+100】之间。

输入-9999时一个多项式结束。

输出：先输出2个多项式，再输出求和后的多项式。

每个式子占据一行。

每一组输入对应的输出包括三行，包括2个多项式以及求和后的多项式。

每个式子占据一行。

例：Input：1 32 2 -8 0 -99991 1023 6 0 -99991 172 10 -9 5 0 2 23 -1 -1 -3 -9999-1 17 -3 9 2 6 7 5 3 -1 -9999Output：A:x^3+2x^2-8B:x^10+2x^3+6A+B:x^10+3x^3+2x^2-2A:x^17+2x^10-9x^5+23x^-1-x^-3B:-x^17-3x^9+2x^6+7x^5+3x^-1A+B:2x^10-3x^9+2x^6-2x^5+26x^-1-x^-3代码：#include <stdio.h>#include <algorithm>#include <string.h>using namespace std;int main(){int x,y; //cishu +100；int i=0;int couna=0,counb=0;int na[300];int nb[300];int nc[300];int flag;while (scanf("%d",&x)!=EOF){flag=0;memset(na,0,sizeof(na));memset(nb,0,sizeof(nb));memset(nc,0,sizeof(nc));while (x!=-9999){scanf("%d",&y);na[y+100]=x;couna++;scanf("%d",&x);}scanf("%d",&x);while (x!=-9999){scanf("%d",&y);nb[y+100]=x;counb++;scanf("%d",&x);}printf("A:");for(i=200;i>=0;i--){if(flag==0&&na[i]!=0){if(i==100){if(na[i]>0)p rintf("%d",na[i]);else printf("%d",na[i]);}else if(i==101){if(na[i]==1)printf("x");else if(na[i]==-1)printf("-x");else if(na[i]>0)printf("%dx",na[i]);elseprintf("%dx",na[i]);}else if(na[i]==1)printf("x^%d",i-100);else if(na[i]==-1)printf("-x^%d",i-100);else if(na[i]>0)printf("%dx^%d",na[i],i-100);elseprintf("%dx^%d",na[i],i-100);flag++;}else if(na[i]!=0){if(i==100){if(na[i]>0)p rintf("+%d",na[i]);else printf("%d",na[i]);}else if(i==101){if(na[i]==1)printf("+x");else if(na[i]==-1)printf("-x");else if(na[i]>0)printf("+%dx",na[i]);elseprintf("%dx",na[i]);}else if(na[i]==1)printf("+x^%d",i-100);else if(na[i]==-1)printf("-x^%d",i-100);else if(na[i]>=0)printf("+%dx^%d",na[i],i-100);elseprintf("%dx^%d",na[i],i-100);}}if(flag==0)printf("\nB:");flag=0;for(i=200;i>=0;i--){if(flag==0&&nb[i]!=0){if(i==100){if(nb[i]>0)printf("%d",nb[i]);else printf("%d",nb[i]);}else if(i==101){if(nb[i]==1)printf("x");else if(nb[i]==-1)printf("-x");else if(nb[i]>0)printf("%dx",nb[i]);elseprintf("%dx",nb[i]);}else if(nb[i]==1)printf("x^%d",i-100);else if(nb[i]==-1)printf("-x^%d",i-100);else if(nb[i]>=0)printf("%dx^%d",nb[i],i-100);elseprintf("%dx^%d",nb[i],i-100);flag++;}else if(nb[i]!=0){if(i==100){if(nb[i]>0)printf("+%d",nb[i]);else printf("%d",nb[i]);}else if(i==101){if(nb[i]==1)else if(nb[i]==-1)printf("-x");else if(nb[i]>0)printf("+%dx",nb[i]);elseprintf("%dx",nb[i]);}else if(nb[i]==1)printf("+x^%d",i-100);else if(nb[i]==-1)printf("-x^%d",i-100);else if(nb[i]>=0)printf("+%dx^%d",nb[i],i-100);elseprintf("%dx^%d",nb[i],i-100);}}if(flag==0)printf("0");for(i=0;i<=200;i++){nb[i]=na[i]+nb[i];}flag=0;printf("\nA+B:");for(i=200;i>=0;i--){if(flag==0&&nb[i]!=0){if(i==100){if(nb[i]>0)printf("%d",nb[i]);else printf("%d",nb[i]);}else if(i==101){if(nb[i]==1)printf("x");else if(nb[i]==-1)printf("-x");else if(nb[i]>0)printf("%dx",nb[i]);elseprintf("%dx",nb[i]);}else if(nb[i]==1)printf("x^%d",i-100);else if(nb[i]==-1)printf("-x^%d",i-100);else if(nb[i]>=0)printf("%dx^%d",nb[i],i-100);elseprintf("%dx^%d",nb[i],i-100);flag++;}else if(nb[i]!=0){if(i==100){if(nb[i]>0)printf("+%d",nb[i]);else printf("%d",nb[i]);}else if(i==101){//printf("nb[i]:%d\n",nb[i]);if(nb[i]==1)printf("+x");else if(nb[i]==-1)printf("-x");else if(nb[i]>0)printf("+%dx",nb[i]);elseprintf("%dx",nb[i]);}else if(nb[i]==1)printf("+x^%d",i-100);else if(nb[i]==-1)printf("-x^%d",i-100);else if(nb[i]>=0)printf("+%dx^%d",nb[i],i-100);elseprintf("%dx^%d",nb[i],i-100);}}if(flag==0)printf("0");printf("\n");}return 0;}运行结果：。

多项式恒等定理在级数求和上的应用

故可
1
(Z n
:
+
l )
“
二 B + `2: 十 l ) C + (3
.
+
3
,:
+
1
)D
+
+
6
,,
“
+
4
,,
+
) E
,
。
值均恒成立
C S
一
* ,
即为恒等式
.
.
根据多项式恒等定理
:
之同次幂系数相等可
,
D 一 O
,
1
,
B 一 0
…
n
’
S 一 A 一 + Zn
`
n
“
+
2 尽`
2 吕
C。 5
)
。
I 一义 6
+ : 。
。
,。 +
叼I
4
e o s
,。
。
c 。 5
2。
。
一叮吕
训丁
8
C 0 5
1 。 + 、匕互〔
。。 s
( 1。
:
)
_
一
卜。。 s
( 1。
一
。
一: 。
。
)〕
。
.
10
-
r
侧丁
二
e
训丁
Z
.
万
~
训丁
二吕
_ `
。
,
八 U
。
u
o
1
— 这里是利用积化和的方法解决的

一元多项式用c语言求和

一元多项式用c语言求和C语言可以使用数组来表示一元多项式，数组的每个元素表示多项式的每一项。

以下是求和的示例代码：```c#include <stdio.h>#define MAX_TERMS 100typedef struct {float coef;int expon;} PolynomialTerm;void add_terms(PolynomialTerm terms[], float coef, int expon, int *term_count) {if (*term_count >= MAX_TERMS) {printf("Too many polynomial terms\n");return;}terms[*term_count].coef = coef;terms[*term_count].expon = expon;(*term_count)++;}float eval_polynomial(PolynomialTerm terms[], int term_count, float x) {float result = 0.0;int i;for (i = 0; i < term_count; i++) {float term_result = terms[i].coef;int j;for (j = 0; j < terms[i].expon; j++) {term_result *= x;}result += term_result;}return result;}int main() {PolynomialTerm terms[MAX_TERMS];int term_count = 0;add_terms(terms, 2.0, 3, &term_count);add_terms(terms, -1.5, 2, &term_count);add_terms(terms, 3.2, 1, &term_count);add_terms(terms, -4.7, 0, &term_count);float x = 2.5;float result = eval_polynomial(terms, term_count, x);printf("The result of evaluating the polynomial at x = %.1f is %.2f\n", x, result);return 0;}```上述代码定义了一个`PolynomialTerm`结构体，每个结构体实例表示多项式的一项，其中`coef`表示系数，`expon`表示指数。

三项裂项求和公式

三项裂项求和公式三项裂项求和公式是高中数学中非常重要的一个公式，它是帮助我们计算多项式的和的一个有用的工具。

这个公式表达的是把一个多项式拆分成三个多项式的和，从而简化计算的过程。

具体来说，三项裂项求和公式的具体形式如下：$$(a + b + c)^2 = a^2 + b^2 + c^2 + 2ab + 2bc + 2ca$$这个公式表达的是，如果我们有一个多项式 $a + b + c$，我们可以把它分成 $a^2$、$b^2$、$c^2$ 以及 $2ab$、$2bc$、$2ca$ 这六个多项式的和。

这个公式非常实用，因为它可以让我们更容易地计算多项式的和。

使用三项裂项求和公式的时候，我们只需要先把要计算的多项式化简成最简形式，然后套用上面的公式即可。

例如，如果我们想计算 $(x + 1 + 2x^2)^2$，我们可以将其拆分成：$$\begin{aligned} (x + 1 + 2x^2)^2 &= x^2 + 1 + 4x^4 + 2x + 2x^3 + 2x^2 \\ &= 4x^4 + 2x^3 + 2x^2 + x^2 + 2x + 1 \\ &= 4x^4 + 2x^3 + 3x^2 + 2x + 1 \end{aligned}$$通过使用三项裂项求和公式，我们成功地把原来的多项式拆分成了三个更简单的多项式，从而简化了计算的过程。

除了上面这个例子之外，三项裂项求和公式还可以用于解决一些其他的数学问题。

例如，在计算多项式乘积的时候，我们也可以利用这个公式来简化计算。

此外，在一些数学竞赛中，三项裂项求和公式也是非常重要的一个工具，因为它可以让我们更快地计算出一些复杂的多项式。

总之，三项裂项求和公式是一种非常实用的数学工具，它可以帮助我们更快地计算多项式的和。

通过学会使用这个公式，我们可以更好地掌握数学知识，更轻松地解决各种数学问题。

c++一元多项式求和顺序表

在C++中，可以使用顺序表来实现一元多项式的求和操作。

一元多项式可以表示为一系列的系数和指数对，例如：3x^2 + 2x + 5。

下面是一个简单的C++代码示例，用于实现一元多项式的求和顺序表：#include <iostream>#include <vector>struct Term {int coefficient; // 系数int exponent; // 指数};// 求和函数std::vector<Term> sumPolynomials(const std::vector<Term>& poly1, const std::vector<Term>& poly2) {std::vector<Term> result;int i = 0, j = 0;while (i < poly1.size() && j < poly2.size()) {if (poly1[i].exponent > poly2[j].exponent) {result.push_back(poly1[i]);i++;} else if (poly1[i].exponent < poly2[j].exponent) {result.push_back(poly2[j]);j++;} else {int sum = poly1[i].coefficient + poly2[j].coefficient;if (sum != 0) {Term term;term.coefficient = sum;term.exponent = poly1[i].exponent;result.push_back(term);}i++;j++;}}// 将剩余的项添加到结果中while (i < poly1.size()) {result.push_back(poly1[i]);i++;}while (j < poly2.size()) {result.push_back(poly2[j]);j++;}return result;}int main() {std::vector<Term> poly1 = {{3, 2}, {2, 1}, {5, 0}}; // 3x^2 + 2x + 5std::vector<Term> poly2 = {{-1, 2}, {3, 1}, {2, 0}}; // -x^2 + 3x + 2std::vector<Term> result = sumPolynomials(poly1, poly2);// 输出结果for (const auto& term : result) {std::cout << term.coefficient << "x^" << term.exponent << " ";}std::cout << std::endl;return 0;}在这个示例中，我们定义了一个结构体Term来表示一元多项式的每一项，然后编写了一个sumPolynomials函数来实现两个多项式的求和操作。

tan麦克劳林公式

tan麦克劳林公式
麦克劳林公式是数学中的一种近似展开方法，用于将一个函数表示为无限项的
多项式求和。

它由苏格兰数学家麦克劳林在18世纪提出，并成为微积分中的重要
工具。

麦克劳林公式的一般形式为：
f(x) = f(a) + f'(a)(x - a) + f''(a)(x - a)^2/2! + f'''(a)(x - a)^3/3! + ...
其中，f(x)是要近似表示的函数，a是展开点，f'(a)、f''(a)、f'''(a)等表示在点a
处的导数。

麦克劳林公式适用于将具有无穷次可导性质的函数在展开点附近进行近似运算。

通过截取具有较高次数的项，可以得到一个简单的多项式函数来近似表示原函数。

这在数学和物理学中有着广泛的应用。

通过麦克劳林公式，我们可以更好地理解函数在某一点的局部行为。

当展开点
选取得当且展开项保留足够多的时候，近似的多项式函数可以非常接近原函数，从而方便我们进行计算和解析。

总结来说，麦克劳林公式是一种将函数近似表示为多项式求和的方法，它在微
积分和物理学中具有广泛的应用。

通过选取合适的展开点和截取足够多的项，我们可以得到一个简化的函数形式，方便我们对原函数进行计算和研究。

多项式系数和公式

多项式系数的求和公式
多项式系数的求和公式：x2+2x-3（2代表2次方）。

如果一个数的n次方（n是大于1的整数）等于a，那么这个数叫做a的n次方根。

当n为奇数时，这个数为a的奇次方根；当n为偶数时，这个数为a的偶次方根。

求一个数a的n次方根的运算叫做开n次方，a叫做被开方数，n 叫做根指数。

简介
在数学中，多项式（polynomial）是指由变量、系数以及它们之间的加、减、乘、幂运算（非负整数次方）得到的表达式。

对于比较广义的定义，1个或0个单项式的和也算多项式。

按这个定义，多项式就是整式。

实际上，还没有一个只对狭义多项式起作用，对单项式不起作用
的定理。

0作为多项式时，次数定义为负无穷大（或0）。

单项式和多项式统称为整式。