多项式求和,C语言,链表

C语言实现多项式的相加

C语⾔实现多项式的相加本⽂实例为⼤家分享了C语⾔多项式相加的具体代码，供⼤家参考，具体内容如下包含带头节点的链表的初始化，输出：#define _CRT_SECURE_NO_WARNINGS#include <stdio.h>#include <stdlib.h>typedef struct Pol{int coe; // 系数int index; // 指数struct Pol *next;}Pol;int main(int argc, char *argv[]){Pol *head1 = NULL; // 第⼀个多项式Pol *head2 = NULL; // 第⼆个多项式Pol *Initiate(Pol *head1); // 声明初始化函数void Output(Pol *head); // 声明输出函数void PolAdd(Pol *head1, Pol *head2); // 声明相加函数int coe, index;char sign;Pol *p;int n = 0;// 初始化第⼀个多项式head1 = Initiate(head1);p = head1;while (1){scanf("%dx%d%c", &coe, &index, &sign);p->next = (Pol *)malloc(sizeof(Pol));p = p->next;p->coe = coe;p->index = index;p->next = NULL;if(sign == '\n')break;}printf("第⼀多项式输⼊完毕。

\n");// 初始化第⼆个多项式head2 = Initiate(head2);p = head2;while (1){scanf("%dx%d%c", &coe, &index, &sign);p->next = (Pol *)malloc(sizeof(Pol));p = p->next;p->coe = coe;p->index = index;p->next = NULL;if (sign == '\n')break;}printf("第⼆多项式输⼊完毕。

链表及其多项式相加

链表及其多项式相加一、实验目的1.了解线性表的链式存储结构，熟练掌握链表。

2.了解作为链表的多项式存贮方式。

3.熟悉掌握多项式加法的算法。

#include<stdio.h>#include <malloc.h>typedef struct linkline{int coef;int exp;struct linkline *next;}line;line *creat(){ /*建立多项式列表*/int n;line *head;line *p1,*p2;n=0;printf("(输入的数必须是整数，指数须从小到大依次输入,系数为零表示多项式结束)\n");p1=p2=(line *)malloc(sizeof(line)); /*开辟一个新单元*/scanf("%d%d",&p1->coef,&p1->exp); /*录入多项式*/if (p1->coef==0) head=0;else{while(p1->coef!=0){n++;if (n==1) head=p1;else p2->next=p1;p2=p1;p1=(line *)malloc(sizeof(line));scanf("%d%d",&p1->coef,&p1->exp);}p2->next=0;}return(head);}/* 以下是输出多项式的函数*/void print(line *p){line *p0;p0=p;printf(" ");do{printf("%dx的%d次幂",p0->coef,p0->exp);p0=p0->next;if(p0!=0) printf("+");}while(p0!=0);else printf(" 空多项式!!");printf("\n");}int compare(int m,int n) /*比较两个整数的大小的函数*/ {int j;if (m<n) j=-1;if (m==n) j=0;if (m>n) j=1;return(j);}void freeNode(line *w1) /* 释放一个表中的所有结点*/ {line *w2;w2=w1->next;while(w1){free(w1);w1=w2;w2=w2->next;}}line *AddLine(line *ha,line *hb) /*两个非空多项式相加*/ {line *la,*lb,*lc;int a,b,sum;lc=ha;la=ha;lb=hb;if ((ha==0)&&(hb!=0)) return(hb);while ((la!=0)&&(lb!=0)){a=la->exp; b=lb->exp;switch( compare(a,b) ) /*比较当前结点指数的大小*/ {{ ha=la; /*只修改la的指针*/la=la->next;break;}case 0:{ sum=la->coef+lb->coef;if(sum!=0){ /* 将其不为零的系数和保存*/la->coef=sum;ha=la; la=la->next;} /* end if*/else{ /* 分别删除系数和为零的对应的两个结点*/if (lc==la) {lc=lc->next;ha=lc;la=ha;} /* 刚开始时特殊处理头结点*/ else{ha->next=la->next;la=ha->next;}} /*end else*/hb=lb;lb=lb->next;break;}case 1:{ /* 将指数小的项插入到la的前部*/hb=lb->next;if(ha==la) {lc=lb;lb->next=ha;la=la->next; }else{ha->next=lb;lb->next=la;ha=la;la=la->next;}lb=hb->next;break;}} /*end swtich*/} /*end while*/if (lb!=0) ha->next=lb;return(lc);} /*end AddLine *//*************以下为主程序**************/main(){line *la,*lb,*lc;printf("请输入多项式La: ");la=creat();printf("请输入多项式Lb: ");lb=creat();printf("多项式La:\n");print(la);printf("多项式Lb:\n");print(lb);printf("多项式La与Lb的和是: \n");lc=AddLine(la,lb);print(lc);freeNode(lb);}二、实验原理顺序存储的线性表有一些弱点，其一，插入与删除元素需要大量移动元素；其二，预先分配存储空间时必须按最大的空间来分配。

数据结构（C语言）用单链表存储一元多项式,并实现两个多项式的相加运算

#include<stdio.h>#include<stdlib.h>#include<malloc.h>typedef int ElemType;/*单项链表的声明*/typedef struct PolynNode{int coef; // 系数int expn; // 指数struct PolynNode *next;}PolynNode,*PolynList;/*正位序(插在表尾)输入n个元素的值，建立带表头结构的单链线性表*/ /*指数系数一对一对输入*/void CreatePolyn(PolynList &L,int n){int i;PolynList p,q;L=(PolynList)malloc(sizeof(PolynNode)); // 生成头结点L->next=NULL;q=L;printf("成对输入%d个数据\n",n);for(i=1;i<=n;i++){p=(PolynList)malloc(sizeof(PolynNode));scanf("%d%d",&p->coef,&p->expn); //指数和系数成对输入q->next=p;q=q->next;}p->next=NULL;}// 初始条件：单链表L已存在// 操作结果: 依次对L的每个数据元素调用函数vi()。

一旦vi()失败,则操作失败void PolynTraverse(PolynList L,void(*vi)(ElemType, ElemType)){PolynList p=L->next;while(p){vi(p->coef, p->expn);if(p->next){printf(" + "); //“+”号的输出，最后一项后面没有“+” }p=p->next;}printf("\n");}/*ListTraverse()调用的函数(类型要一致)*/void visit(ElemType c, ElemType e){if(c != 0){printf("%dX^%d",c,e); //格式化输出多项式每一项}}/* 多项式相加，原理：归并 *//* 参数：两个已经存在的多项式 *//* 返回值：归并后新的多项式的头结点 */PolynList MergeList(PolynList La, PolynList Lb){PolynList pa, pb, pc, Lc;pa = La->next;pb = Lb->next;Lc = pc = La; // 用La的头结点作为Lc的头结点while(pa&&pb){if(pa->expn < pb->expn){pc->next = pa; //如果指数不相等，pc指针连上指数小的结点，pc = pa;pa = pa->next; //指向该结点的指针后移}else if(pa ->expn > pb->expn ){pc->next = pb; //pc指针连上指数小的结点，pc = pb;pb = pb->next; //指向该结点的指针后移}else//(pa ->expn = pb->expn ){pa->coef = pa->coef + pb->coef; //指数相等时，系数相加 pc->next = pa;pc = pa;pa = pa->next; //两指针都往后移pb = pb->next;}}pc->next = pa ? pa:pb; // 插入剩余段return Lc;}void main(){PolynList ha,hb,hc;printf("非递减输入多项式ha， ");CreatePolyn(ha,5); // 正位序输入n个元素的值printf("非递减输入多项式hb， ");CreatePolyn(hb,5); // 正位序输入n个元素的值printf("多项式ha :");PolynTraverse(ha, visit); printf("\n");printf("多项式hb :"); PolynTraverse(hb, visit); printf("\n");hc = MergeList(ha,hb); PolynTraverse(hc, visit); }。

单链表应用之稀疏多项式求和（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; }。

C语言单链表实现多项式相加

C语⾔单链表实现多项式相加本⽂实例为⼤家分享了C语⾔单链表实现多项式相加的具体代码，供⼤家参考，具体内容如下//多项式的相加和相乘#include<stdio.h>#include<stdlib.h>#pragma warning(disable:4996)//兼容scanftypedef struct node {int coef;int expon;struct node* link;}Polynode,*Polynomial;Polynomial InsertPolyLinklist(Polynomial in,Polynomial Pread) {Pread->link = in;Pread = in;in->link = NULL;return Pread;}Polynomial ReadPoly(void) {Polynomial Pread = (Polynomial)malloc(sizeof(Polynode));Pread->link = NULL;Polynomial H = Pread;int N;scanf("%d ", &N);while (N--) {Polynomial p = (Polynomial)malloc(sizeof(Polynode));scanf("%d %d", &p->coef, &p->expon);Pread= InsertPolyLinklist(p,Pread);}Polynomial F;F = H->link;free(H);return F;}void PrintPoly(Polynomial F) {while(F != NULL) {printf("%d %d ", F->coef, F->expon);F = F->link;}printf("\n");}Polynomial Add(Polynomial p1, Polynomial p2) {Polynomial t1=p1,t2=p2;Polynomial p=(Polynomial)malloc(sizeof(Polynode));p->link = NULL;Polynomial q = p;Polynomial read;while (t1&&t2) {if (t1->expon == t2->expon) {if (t1->coef + t2->coef) {t1->coef = t1->coef + t2->coef;t1->expon = t1->expon;read = t1;q->link = read;q = read;t1 = t1->link;t2 = t2->link;}}else {if (t1->expon > t2->expon){read = t1;q->link = read;q = read;t1 = t1->link;}else {if (t1->expon < t2->expon) {read = t2;q->link = read;q = read;t2 = t2->link;}}}}if (t1) {q->link = t1;}if (t2) {q->link = t2;}Polynomial F = p->link;free(p);return F;}int main(void) {Polynomial p1, p2, pp, ps;p1 = ReadPoly();PrintPoly(p1);p2 = ReadPoly();PrintPoly(p2);pp = Add(p1, p2);PrintPoly(pp);// ps = Mult(p1, p2);// PrintPoly(ps);return 0;}参考MOOC 浙⼤数据结构以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

数据结构多项式求和实验报告

1.实验题目设计一种用单链表存储多项式的结构（每个结点存储一项的系数和指数，类型都为int），并编写一个产生多项式链表的函数和一个实现两个多项式相加的函数。

2 .实验内容顺序存储结构的实现。

先输入多项式最高项数，然后按照（系数，指数）的格式输入顺序表类型定义如下：typedef struct term{int coef;int expn;struct term *next;}term,*Polynomial;3．实验要求（1）利用C语言完成算法设计和程序设计。

（2）上机调试通过实验程序。

（3）输入数据，检验程序运行结果。

（4）给出具体的算法分析，包括时间复杂度和空间复杂度。

（5）撰写实验报告。

4.实验步骤与源程序⑴实验步骤首先分析实验内容，要实现多项式求和，必须创建两个函数，然后先建立一个多项式a和多项式b，接着输入每个多项式的系数和指数，再实现多项式a和b的求和将求出的多项式放在多项式a中，最后输出求出的多项式的结果。

⑵源代码#include<stdio.h>#include<stdlib.h>#include<string.h>#include<time.h>#include<malloc.h>/*定义存储结构，用单链表存储多项式，链表中每个结点存储多项式中的一项。

*/typedef struct term{int coef;//定义多项式系数为coefint expn;//定义多项式指数为expnstruct term *next;}term,*Polynomial;void Create_Polynomial(Polynomial *P,int n){ /*建立多项式*/int i;term *t1,*t2;(*P)=(term *)malloc(sizeof(term));(*P)->coef=0;(*P)->expn=0;(*P)->next=NULL;t1=(*P);for(i=0;i<=n;i++){ /*输入每一项的系数和指数*/ t2=(term *)malloc(sizeof(term));scanf("%d,%d",&(t2->coef),&(t2->expn));t1->next=t2;t1=t1->next;}t2->next=NULL;}void Add_Polynomial(Polynomial *a,Polynomial *b){ /*多项式a和多项式b求和，结果存放在a中。

多项式相加c语言

Print(&sum);
reset(&p);
reset(&q);
reset(&sum);
return 0;
}
```
在上述代码中，首先定义了一个`Node`结构体，包含多项式的系数和指数，并通过链表的方式存储多项式的每一项。然后，实现了一系列函数，包括多项式的增加、输出、相加和消除。在`main`函数中，调用这些函数来完成多项式的输入、相加和输出。
请注意，这只是一个简单的示例，实际应用中可能需要考虑更多的边界情况和错误处理。
以下是一个简单的 C 语言示例，展示了如何实现多项式相加：
```c
#include <stdio.h>
#include <stdlib.h>
// 定义结构的数据部分
struct poly {it zhishu;float xishu;
};
// 定义一个多项式结构
typedef struct node {
s->date.xishu = s->date.xishu + s->next->date.xishu;
s->next = s->next->next;
} else {
s = s->next;
}
}
d = d->next;
}
}
// 链表的消除函数
void reset(Node *pList) {
Node *p = pList;
while (p->next) {
if (flog == 1)
printf(" + ");
else {

c++一元多项式相加减链表

C++一元多项式相加减链表一、介绍1. 什么是一元多项式一元多项式是指只含有一个变量的多项式，例如3x^3 + 2x^2 - 5x + 7。

2. 链表的概念链表是一种数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的指针。

3. 本文内容本文将介绍如何使用C++实现一元多项式的相加和相减运算，同时利用链表来存储和操作多项式的数据。

二、实现思路1. 链表的设计我们可以设计一个节点类来表示多项式的每一项，节点包括系数和指数两个成员变量，同时包括一个指针指向下一个节点。

2. 多项式的输入和输出用户可以逐项输入多项式的系数和指数，也可以将多项式输出至屏幕或文件。

3. 多项式的相加和相减我们需要同时遍历两个多项式的链表，根据指数的大小进行相应的相加或相减操作，并将结果存储到一个新的链表中。

三、代码实现1. 定义节点类```class Node {public:int coefficient; // 系数int exponent; // 指数Node* next; // 指向下一个节点的指针};```2. 多项式的输入```void inputPolynomial(Node* &head) {// 逐项输入多项式的系数和指数，并将其存储为一个链表 }```3. 多项式的输出```void outputPolynomial(Node* head) {// 遍历链表，并将多项式的每一项输出至屏幕或文件}```4. 多项式的相加```Node* addPolynomial(Node* head1, Node* head2) {// 遍历两个链表，根据指数的大小进行相应的相加操作，并将结果存储到一个新的链表中}```5. 多项式的相减```Node* subtractPolynomial(Node* head1, Node* head2) {// 遍历两个链表，根据指数的大小进行相应的相减操作，并将结果存储到一个新的链表中}```四、示例代码1. 主函数```int main() {Node* head1 = nullptr;Node* head2 = nullptr;Node* result = nullptr;// 输入第一个多项式inputPolynomial(head1);// 输入第二个多项式inputPolynomial(head2);// 输出两个多项式cout << "First polynomial: ";outputPolynomial(head1);cout << "Second polynomial: ";outputPolynomial(head2);// 计算两个多项式的和result = addPolynomial(head1, head2);cout << "Sum of two polynomials: ";outputPolynomial(result);// 计算两个多项式的差result = subtractPolynomial(head1, head2); cout << "Difference of two polynomials: "; outputPolynomial(result);return 0;}```五、总结本文介绍了如何使用C++实现一元多项式的相加和相减运算，并利用链表来存储和操作多项式的数据。

数据结构C语言描述——用单链表实现多项式的相加

数据结构C语⾔描述——⽤单链表实现多项式的相加#include <stdio.h>#include <stdlib.h>typedef DataType;typedef struct Node2{DataType xishu;DataType zhisu;struct Node2 *Next;}Node2;typedef struct Node2* PNode2;//多项式按照指数⼤⼩排序void insertNewPoint_link(PNode2 head,PNode2 qNode){PNode2 p=head;while (p->Next!=NULL){if (p->Next->zhisu>qNode->zhisu){qNode->Next=p->Next;p->Next=qNode;break;}p=p->Next;}if (p->Next==NULL){p->Next=qNode;}}//打印多项式void printLinkeLink(PNode2 head){PNode2 temp=head->Next;while (temp!=NULL){printf("%d %d",temp->xishu,temp->zhisu);printf("\n");temp=temp->Next;}}//多项式的加法计算void add_poly(Node2 *pa,Node2 *pb){Node2 *p=pa->Next;Node2 *q=pb->Next;Node2 *pre=pa;Node2 *u;while (p!=NULL&&q!=NULL){if (p->zhisu<q->zhisu){pre=p;p=p->Next;}else if(p->zhisu==q->zhisu){float x=p->xishu+q->xishu;if (x!=0){p->xishu=x;pre=p;}else{pre->Next=p->Next;//指向下⼀个结点free(p);}p=pre->Next;u=q;q=q->Next;free(u);}else{u=q->Next;q->Next=p;pre->Next=q;pre=q;q=u;}}if (q){pre->Next=q;}free(pb);}void main( ){int zhishu;float xishu;PNode2 head1=(PNode2)malloc(sizeof(struct Node2));PNode2 head2=(PNode2)malloc(sizeof(struct Node2));PNode2 tem=NULL;head1->Next=NULL;head2->Next=NULL;printf("输⼊链表⼀的系数和指数，如：3,2 以0,0结束输⼊：\n"); scanf("%f,%d",&xishu,&zhishu);while (xishu!=0||zhishu!=0){tem=(PNode2)malloc(sizeof(struct Node2));tem->xishu=xishu;tem->zhisu=zhishu;tem->Next=NULL;insertNewPoint_link(head1,tem);scanf("%f,%d",&xishu,&zhishu);}printf("链表⼀按指数升序排序后的多项式为：\n");printLinkeLink(head1);printf("\n");printf("输⼊链表⼀的系数和指数，如：3,2 以0,0结束输⼊：\n"); scanf("%f,%d",&xishu,&zhishu);while (xishu!=0||zhishu!=0){tem=(PNode2)malloc(sizeof(struct Node2));tem->xishu=xishu;tem->zhisu=zhishu;tem->Next=NULL;insertNewPoint_link(head2,tem);scanf("%f,%d",&xishu,&zhishu);}printf("链表⼆按指数升序排序后的多项式为：\n");printLinkeLink(head2);printf("\n");add_poly(head1,head2);printf("多项式相加后的结果为：\n");printLinkeLink(head1);}。

多项式求和,C语言,链表

计算机科学与工程学院《算法与数据结构》试验报告[二]专业班级10级计算机工程02 试验地点计算机大楼计工教研室学生学号1005080222 指导教师蔡琼学生姓名肖宇博试验时间2012-4-7试验项目算法与数据结构试验类别基础性（）设计性（）综合性（√）其它（）试验目的及要求（1）熟练掌握链表结构及有关算法的设计；（2掌握用链表表示特定形式的数据的方法，并能编写出有关运算的算法。

成绩评定表类别评分标准分值得分合计上机表现积极出勤、遵守纪律主动完成设计任务30分程序与报告程序代码规范、功能正确报告详实完整、体现收获70分备注：评阅教师：日期：年月日试验内容一、实验目的和要求1、实验目的：（1）掌握用VC++上机调试线性表的基本方法；（2）掌握顺序表的存储结构以及基本运算的实现。

2、实验内容把任意给定的两个一元多项式P(x),Q(x)输入计算机，计算它们的和并输出计算结果。

3、实验要求：用链表实现。

二、设计分析一元多项式可以用单链表表示，结点结构图示如下：coef exp next一元多项式链表的结点结构一元多项式算法伪代码如下：1. 工作指针p、q初始化；2. while（p存在且q存在）执行下列三种情形之一2.1 如果p->exp<q->exp，则指针p后移;2.2 如果p->exp>q->exp，则2.2.1 将结点q插入到结点p之前；2.2.2 指针q指向原指结点的下一个结点；2.3 如果p->exp=q->exp，则2.3.1 p->coef =p->coef+q->coef；2.3.2 如果p->coef ==0，则执行下列操作，否则，指针p后移;2.3.2.1 删除结点p；2.3.2.2 使指针p指向它原指结点的下一个结点；2.3.3 删除结点q；2.3.4 使指针q指向它原指结点的下一个结点；3. 如果q不为空，将结点q链接在第一个单链表的后面；三、源程序代码#include<stdio.h>#include<stdlib.h>#define MAXSIZE 100typedef struct pnode{float coef; //多项式系数int exp; //多项式指数struct pnode *next;}polynode;void Inipnode(polynode *&p) //初始化{p=(polynode *)malloc(sizeof(polynode));p->next=NULL;}void Creatpnode_R(polynode *&p) //尾插法建立头结点{int len=0;polynode *s,*r;p=(polynode *)malloc(sizeof(polynode));r=p;label: printf("请输入您要输入多少个多项式");printf("\n");scanf("%d",&len);if(len<=0){printf("*********************************************************** *");printf("\n");printf("\t\t输入有误! 请重新输入！");printf("\n");printf("*********************************************************** *");printf("\n");goto label;}else{for(int i=0;i<len;i++){s=(polynode *)malloc(sizeof(polynode));label2: printf("请输入第%d项的系数",i+1);scanf("%f",&(s->coef));if(s->coef==0){printf("零输入它干嘛！重新输入！");printf("\n");goto label2;}printf("请输入第%d项的指数",i+1);scanf("%d",&(s->exp));r->next=s;r=s;}r->next=NULL;}}void Dispnode(polynode *p){polynode *s=p->next;if(s==NULL) //如果所有的项都被消去{printf("您输入的多项式为F(a)=0");printf("\n");}else //如果还有多项式{printf("您输入的多项式为F(a)=");while(s!=NULL){if(s->next!=NULL) //如果数据接点不是最终的接点，就要一个加号{printf("%.1fa%d+",s->coef,s->exp);}else //如果数据接点是最终的接点，不要加号{printf("%.1fa%d",s->coef,s->exp);}s=s->next; //指向下一个接点}printf("\n");}}void Addpnode(polynode *polya,polynode *polyb,polynode *&polyc){polynode *r,*p,*q,*m;polyc=(polynode *)malloc(sizeof(polynode)); //用尾插法创建第三个链表polyc->next=NULL;r=polyc;p=polya->next; //p,q 是数据接点q=polyb->next;while(p!=NULL&&q!=NULL){if(p->exp>q->exp){r->next=p;r=p;p=p->next;}else if(p->exp<q->exp){r->next=q;r=q;q=q->next;}else if(p->exp==q->exp){m=(polynode *)malloc(sizeof(polynode));m->next=NULL;m->coef=p->coef+q->coef;m->exp=p->exp;if(m->coef!=0){r->next=m;r=m;}p=p->next;q=q->next;}}while(q!=NULL){r->next=q;q=q->next;}while(p!=NULL){r->next=p;p=p->next;}}void main(){polynode *p1;polynode *p2;polynode *p3;Inipnode(p1);Inipnode(p2);Inipnode(p3);Creatpnode_R(p1);Creatpnode_R(p2);Dispnode(p1);Dispnode(p2);printf("-------------------------------------------------");printf("\n");Addpnode(p1,p2,p3);Dispnode(p3);}四、测试用例（尽量覆盖所有分支）1.正常状态下，输入无错误后的运行程序如下：2.当输入的多项式系数如果为负或者为零时：3.当输入的多项式，有的项为零时，约去该项的情况如图：4．当所有的输入项都为零的时候：5.当两个相加的项数不一样多的时候：五、实验总结先后学习了C/C++,对编程语言基本上有一些了解，但在数据结构试验程序设计过程中还是学到了很多。

多项式加法的链表设计与实现

r=h; /*r指针始终动态指向链表的当前表尾，以便于做尾插入，其初值指向头结点*/
printf("coef:");
scanf("%d",&c); /*输入系数*/
printf("exp: ");
scanf("%d",&e); /*输入指针*/
while(c!=0) /*输入系数为0时，表示多项式的输入结束*/
//////补充代码......
pre->next=p;
}
else if(p->exp==q->exp) /*若指数相等，则相应的系数相加*/
{
sum=p->coef+q->coef;
if(sum!=0)
{/*将p结点加入到和多项式中,删除结点q*/
p->coef=sum;
pre->next=p;pre=pre->next;p=p->next;
polyb=create(); /*调用建立链表函数，创建多项式B*/
print(polyb);
printf("Sum of the poly is:\n");
polyadd(polya,polyb); /*调用一元多项式相加函数*/
print(polya); /*调用输出函数，打印结果*/
printf("\n");
存放在多项式polya中，并将多项式ployb删除*/
{
node *p,*q,*pre,*temp;
int sum;
p=polya->next;/*令p和q分别指向polya和polyb多项式链表中的第一个结点*/

多项式相加c语言程序

#include "stdafx.h"//备注：我用的编译平台所提供的头文件不是“stdio.h"#include"malloc.h"#include<cstdlib> //此头文件用来解决执行可以执行文件exe后直接退出的问题，希望可以帮到大家了解一个新函数和头文件typedef struct List{ //定义一个动态链表float coef;int expn;struct List *next;}*list;list initlist()//初始化，生成新结点{list l;l=(list)malloc(sizeof(List));if (!l) printf("error");l->next=NULL;return l;}void insertlist (list l,float *coe,int *exp)//每次scanf后插入结点，从链尾插入，main函数中定义一个链表尾指针{list s;s=(list)malloc(sizeof(List));if(!s)printf("error");s->coef=*coe;s->expn=*exp;l->next =s;s->next =NULL;}void putout(list l)//输出链表{list p;p=l->next;while(p->next){ if(p->expn==0)printf("1+");else if(p->coef==1&&p->expn==1){printf("x+");}elseprintf("%.2fx^%d+",p->coef,p->expn);p=p->next ;} if(p->expn==0)printf("1\n");else if(p->coef==1&&p->expn==1){printf("x\n");}elseprintf("%.2fx^%d\n",p->coef,p->expn);}int cmp(int f,int g) //比较函数，用来判定当前两多项式指数问题{if (f<g)return (-1);else if(f==g)return 0;elsereturn (1);}void addlist(list n,list m){//多项式相加list hn,hm,pn,pm;float sum;pn=n->next ;pm=m->next ;hn=n;hm=m;//定义一个当前节点的指针和一个头指针while(hn->next&&hm->next){switch (cmp(pn->expn,pm->expn))//比较两指数{case -1:hn=pn;pn=pn->next;break;case 0:sum=pn->coef +pm->coef ;if(sum!=0){pn->coef =sum;pm=pm->next ;free(hm->next);hm->next =pm;hn=hn->next ;pn=pn->next ;}//ifelse {hn->next =pn->next ;free(pn);pn=hn->next ;hm->next =pm->next ;free(pm);pm=hm->next ;}break;//elsecase 1:hm->next =pm->next ;hn->next=pm;pm->next =pn;hn=pm;pn=pn->next ;pm=hm->next ;break;}//switch}//whileif(hm->next ) //参考书本43页算法的思想，将剩余结点插入当前链表中{hn->next=pm;free(hm);}}//addlistvoid chongpaixu(list l)//将输入的多项式按升序排列，并将指数相同的合并（还不能执行）{ list s;list q;list k;list w;float sum;k=initlist();q=l->next ;s=l;while(q->next){for(w=l ;q->next !=NULL;q=q->next ){for (s=s->next ;s->next!=NULL;s=s->next ){switch(cmp(s->expn,q->expn)){case -1:w=w->next ;break;case 1:k->coef=q->coef;q->coef=s->coef;s->coef=k->coef;k->expn=q->expn ;q->expn =s->expn ;s->expn =k->expn ;free(k);w=w->next ;break;case 0:sum=s->coef+q->coef;if(sum){s->coef=sum;s->next=q;free(q);q=s->next ;}//ifelse {w->next=q->next;free(s);free(q);s=w->next ;q=s->next ;}//elsebreak;}//switch}}}//while}void putmessage(void)//用来表明备注{printf("备注：该算法经过上课时老师给我们提出的问题进行了修改，不过关于排序的算法还不能完善\n");printf("因此，请输入时请将多项式按照升序输入，将相同指数合并！\n");printf("\n");printf("\n");printf("\n");printf("\n");printf("\n");printf("\n");}void main(){list l,s,hl,hs; int i,d,exp;float *q;int *w;float coe;putmessage();q=&coe;w=&exp;l=initlist();s=initlist();hl=l;hs=s;printf("请输入l的项数\n");scanf("%d",&d);if(d>0){for (i=0;i<d;i++){printf("请输入第%d项的系数\n",i+1);scanf("%f",&coe);printf("请输入第%d项的指数\n",i+1);scanf("%d",&exp);if(coe){insertlist(hl,q,w);hl=hl->next ;}}/*chongpaixu(l);*/if(l->next ){printf("你输入的多项式是f(x)=");putout(l);}else printf("你输入的多项式是f(x)=0\n"); }else printf("你输入的多项式l不存在\n");printf("请输入s的项数\n");scanf("%d",&d);if(d>0){for (i=0;i<d;i++){printf("请输入第%d项的系数\n",i+1);scanf("%f",&coe);printf("请输入第%d项的r指数\n",i+1);scanf("%d",&exp);if(coe){insertlist(hs,q,w);hs=hs->next ;}}if(s->next){printf("你输入的多项式是f(x)=");putout(s);}else printf("你输入的多项式是f(x)=0\n");}else printf("你输入的多项式不存在\n");hl=l;hs=s;if(hl->next &&hs->next ){addlist(l,s);printf("合并后的多项式f(x)=");if(l->next){putout(l);}else printf("0\n");}else printf("no add\n");system ( "pause" );//不加此语句，exe文件在执行完毕直接跳出}。

两多项式求和（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++)<>。

（链表实现）写出两个一元多项式相加的算法

（链表实现）写出两个⼀元多项式相加的算法int c, e;head=new node; //⽣成头结点head->next=NULL;cout<<"请分别输⼊新的⼀项的系数、指数(以输⼊9999作为结束):"<<endl;cin>>c>>e;while(c!=9999 && e!=9999) //输⼊并检测结束{s=new node; //⽣成新结点s->co = c; //装⼊数据s->exp = e;p=head;while(p->next!=NULL){p=p->next;}p->next = s; //插到最后⼀个结点后s->next = NULL;cout<<"请分别输⼊新的⼀项的系数、指数(以输⼊9999作为结束):"<<endl;cin>>c>>e;}return head;}void Display(node * head){if(head==NULL){cout<<"多项式不存在！"<<endl;return ;}node* p;p=head->next;while(p!=NULL){if(p->co>0)cout<<p->co<<"x^"<<p->exp;elsecout<<"("<<p->co<<")"<<"x^"<<p->exp;if(p->next!=NULL)cout<<"+";p=p->next;}cout<<endl<<endl;}node* Add(node * A, node * B){node * C=new node;C->next=NULL;node * p1=A->next;node * p2=B->next;node * p3;node * rearC=C;while(p1!=NULL && p2!=NULL){。

数据结构(C语言)用单链表存储一元多项式,并实现两个多项式的相加运算

#include<stdio.h>#include<stdlib.h>#include<malloc.h>typedef int ElemType;/*单项链表的声明*/typedef struct PolynNode{int coef; // 系数int expn; // 指数struct PolynNode *next;}PolynNode,*PolynList;/*正位序(插在表尾)输入n个元素的值，建立带表头结构的单链线性表*/ /*指数系数一对一对输入*/void CreatePolyn(PolynList &L,int n){int i;PolynList p,q;L=(PolynList)malloc(sizeof(PolynNode)); // 生成头结点L->next=NULL;q=L;printf("成对输入%d个数据\n",n);for(i=1;i<=n;i++){p=(PolynList)malloc(sizeof(PolynNode));scanf("%d%d",&p->coef,&p->expn); //指数和系数成对输入q->next=p;q=q->next;}p->next=NULL;}// 初始条件：单链表L已存在// 操作结果: 依次对L的每个数据元素调用函数vi()。

一旦vi()失败,则操作失败void PolynTraverse(PolynList L,void(*vi)(ElemType, ElemType)){PolynList p=L->next;while(p){vi(p->coef, p->expn);if(p->next){printf(" + "); //“+”号的输出，最后一项后面没有“+”}p=p->next;}printf("\n");}/*ListTraverse()调用的函数(类型要一致)*/void visit(ElemType c, ElemType e){if(c != 0){printf("%dX^%d",c,e); //格式化输出多项式每一项 }}/* 多项式相加，原理：归并 *//* 参数：两个已经存在的多项式 *//* 返回值：归并后新的多项式的头结点 */PolynList MergeList(PolynList La, PolynList Lb){PolynList pa, pb, pc, Lc;pa = La->next;pb = Lb->next;Lc = pc = La; // 用La的头结点作为Lc的头结点while(pa&&pb){if(pa->expn < pb->expn){pc->next = pa; //如果指数不相等，pc指针连上指数小的结点，pc = pa;pa = pa->next; //指向该结点的指针后移}else if(pa ->expn > pb->expn ){pc->next = pb; //pc指针连上指数小的结点，pc = pb;pb = pb->next; //指向该结点的指针后移}else//(pa ->expn = pb->expn ){pa->coef = pa->coef + pb->coef; //指数相等时，系数相加pc->next = pa;pc = pa;pa = pa->next; //两指针都往后移pb = pb->next;}}pc->next = pa ? pa:pb; // 插入剩余段return Lc;}void main(){PolynList ha,hb,hc;printf("非递减输入多项式ha， ");CreatePolyn(ha,5); // 正位序输入n个元素的值 printf("非递减输入多项式hb， ");CreatePolyn(hb,5); // 正位序输入n个元素的值 printf("多项式ha :");PolynTraverse(ha, visit);printf("\n");printf("多项式hb :");PolynTraverse(hb, visit);printf("\n");hc = MergeList(ha,hb);PolynTraverse(hc, visit);}。

多项式相加(含运行结果截图)

while (r){
printf("指数：%d系数：%f\n",r->expn,r->coef);
r=r->next;
}
}
main()
{
void creatpolyn(struct linklist *p,int n); //输入n项的系数，建立一个链表
struct linklist * addpolyn(struct linklist*p,struct linklist*q); //两个多项式相加,返回结果指针
la->coef=s; //此项不为0需要修改la中当前节点的系数值
la=la->next;
p=p->next;
lb=lb->next;
q=q->next;
}
else {
p->next=la->next;
r=la;
la=la->next;
free(r);
lb=lb->next;
q=q->next;
}
scanf("%d",&n);
creatpolyn(p,n);
printf("请输入第二个多项式的项数:\n");
scanf("%d",&n);
creatpolyn(q,n);
r=addpolyn(p,q);
print(r);
}
四．算法分析
多项式由系数和指数组成，建立两个链表分别存储系数和指数。为了方便实验过程，实验在输入的时候按照指数的由低到高输入，避免了排序。在相加过程中，将两个链表从头到尾进行比较，直到比到一个链表没有元素为止，将其中指数相同的系数进行加减运算。最后打印出多项式。

多项式相加的函数（数据结构_C语言版）

多项式相加的函数（数据结构_C语言版）一、编写一个程序用单链表存储多项式，并实现两个多项式相加的函数。

【源程序】#include#include#define MAX 20typedef struct{ float coef;int exp;}PolyArray[MAX];typedef struct pnode{ float coef;//系数int exp;//指数struct pnode *next;}PolyNode;void DispPoly(PolyNode *L)//输出多项式{ PolyNode *p=L->next;while(p!=NULL){ printf("%gx^%d",p->coef,p->exp);p=p->next;}printf("\n");}void CreateListR(PolyNode *&L,PolyArray a,int n)//尾插法建立单链表{ PolyNode *s,*r;int i;L=(PolyNode *)malloc(sizeof(PolyNode)); //创建头结点L->next=NULL;r=L; //r始终指向终端结点,开始时指向头结点for (i=0;i<n;i++)< p="">{s=(PolyNode *)malloc(sizeof(PolyNode));//创建新结点s->coef=a[i].coef;s->exp=a[i].exp;r->next=s; //将*s插入*r之后r=s;}r->next=NULL;}void Sort(PolyNode *&head)//按exp域递减排序{ PolyNode *p=head->next,*q,*r;if(p!=NULL){ r=p->next;p->next=NULL;p=r;while(p!=NULL){ r=p->next;q=head;while(q->next!=NULL&&q->next->exp>p->exp)q=q->next;p->next=q->next;q->next=p;p=r;}}}void Add(PolyNode *ha,PolyNode *hb,PolyNode *&hc)//求两个有序集合的并{PolyNode *pa=ha->next,*pb=hb->next,*s,*tc;float c;hc=(PolyNode *)malloc(sizeof(PolyNode));tc=hc;while(pa!=NULL&&pb!=NULL){ if(pa->exp>pb->exp){ s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pa->exp;s->coef=pa->coef;tc->next=s;tc=s;pa=pa->next;}else if(pa->expexp){ s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pb->exp;s->coef=pb->coef;tc->next=s;tc=s;pb=pb->next;}else{ c=pa->coef+pb->coef;if(c!=0)//系数之和不为0事创建新结点{ s=(PolyNode *)malloc(sizeof(PolyNode));s->exp=pa->exp;s->coef=c;tc->next=s;tc=s;}pa=pa->next;pb=pb->next;}}if(pb!=NULL)pa=pb;//复制余下的结点while(pa!=NULL){ s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pa->exp;s->coef=pa->coef;tc->next=s;tc=s;pa=pa->next;}tc->next=NULL;}void main(){PolyNode *ha,*hb,*hc;PolyArray a={{1.5,0},{2.5,1},{3.3,3},{-2.5,5}};PolyArray b={{-1.5,0},{2.5,1},{3.7,3},{-2.5,5},{5.6,7}};CreateListR(ha,a,4);CreateListR(hb,b,5);printf("原多项式A为：");DispPoly(ha);printf("原多项式B为：");DispPoly(hb);Sort(ha);Sort(hb);printf("有序多项式A：");DispPoly(ha);printf("有序多项式B：");DispPoly(hb);Add(ha,ha,hc);printf("多项式相加结果：");DispPoly(hc); printf("\n");}</n;i++)<>。

数据结构（Datastructure）：用链表实现多项式的表示和运算（C语言）

数据结构（Datastructure）：⽤链表实现多项式的表⽰和运算（C语⾔）0.简介（在以下环境下运⾏通过）：运⾏环境：Linux(ubuntu12.10); 编译器：gcc; 语⾔：C语⾔；作者：Catcher24。

1.问题描述：使⽤链表实现多项式的表⽰和运算（加法、减法、乘法）。

2.数据结构描述与设计：　2.1　使⽤链表的原因：有两个多项式： P1 = 6x^4+4x^2-x; P2 = -7x^5+x^2; 如果要对两个多项式进⾏操作（多项式相加、除法等等......），可以采⽤数组的存储⽅式。

设多项式P(n) = a1x n+a2x n-1+...a n;如果采⽤数组A[n]来存储P(n)的系数，当P(n)中有的a i为0时，数组储存在空间上会带来很⼤的浪费。

⽽采⽤链表存储，每个节点存储系数和指数信息。

⽤链表来表⽰多项式，节点信息如下图：图：链表节点信息　2.2　多项式的链表实现：下⾯给出polynomial.h⽂件，⾥⾯包含了节点的定义和函数定义；1 #include <stdlib.h>2 #include <stdio.h>34 #ifndef _List_H5 typedef int bool;6 typedef int exp_type;7 typedef float coe_type;8#define true 19#define false 010 typedef struct node {11 coe_type coefficient;12 exp_type exponent;13struct node* next;14 }node;15 typedef struct node* polynomial;1617 node* init(node* l);18 node* make_empty(node* l);19bool is_empty(node* l);20bool is_last(node* p,node* l);21 node* find(coe_type x,node* l);22 node* find_previous(coe_type x,node *l);23void delete_node(coe_type x, node* l);24void insert(coe_type x,exp_type y,node* l);25void delete_list(node* l);26 node* header(node* l);27 node* first(node* l);28void print_list(node* l);2930 polynomial create(polynomial poly,coe_type coe[],exp_type exp[],int n);32 polynomial sub_poly(const polynomial poly1,const polynomial poly2,polynomial polyprod);33 polynomial mult_poly(const polynomial poly1,const polynomial poly2,polynomial polyprod);34void print_poly(const polynomial poly);3536#endif 其中通过create()函数创建⼀个新的多项式，⽤⼀个float类型的数组来表⽰多项式的系数，⽤int型的数组来表⽰多项式的指数。

多项式求和,C语言,链表

C语言实现多项式的相加

链表及其多项式相加

数据结构（C语言）用单链表存储一元多项式,并实现两个多项式的相加运算

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

C语言单链表实现多项式相加

数据结构多项式求和实验报告

多项式相加c语言

c++一元多项式相加减 链表

数据结构C语言描述——用单链表实现多项式的相加

多项式求和,C语言,链表

多项式加法的链表设计与实现

多项式相加c语言程序

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

（链表实现）写出两个一元多项式相加的算法

数据结构(C语言)用单链表存储一元多项式,并实现两个多项式的相加运算

多项式相加(含运行结果截图)

多项式相加的函数（数据结构_C语言版）

数据结构（Datastructure）：用链表实现多项式的表示和运算（C语言）

c++一元多项式相加减链表