数据结构课程设计报告（一元多项式的计算）

数据结构课程设计－－一元多项式计算~

#include "stdafx.h"
#include "iostream"
using namespace std;
#define MAXSIZE 10
typedef struct
{
int xi;
int zhi;
}DataType;
typedef struct node
{
DataType data[MAXSIZE];
int length;
}Dx,*PDx;
PDx Init_List()
{
Dx *S;
S=(Dx *)malloc(sizeof(Dx));
if(S)
S->length=0;
return S;
}
int Empty(Dx *S)
{
if(S->length==0)
return 1;
else return 0;
}
int In_list(Dx *S,DataType a)//建立多项式存储结构
{
if(S&&S->length<MAXSIZE)
{
S->length++;
S->data[S->length-1]=a;
return 1;
}
else return 0;
}
int Insert_list(Dx *S,int j,DataType e)//插入
{
if(S&&S->length<MAXSIZE)
{
S->length++;
for(int i=S->length-1;i>j;i--)
S->data[i]=S->data[i-1];
S->data[j]=e;
return 1;
}
else return 0;
}
int Delete_list(Dx *S,int m)//m就是数组下标
{
if(!S)
{
cout<<"多项式不存在！"<<endl;
return -1;
}
if(mS->length)
{
cout<<"删除位置不合法！"<<endl;
return 0;
}
for(int j=m;jlength;j++)
S->data[j-1]=S->data[j];
S->length--;
return 1;
}
PDx Luru(int n)//录入多项式，并存储起来,n为多项式的项数！
{
Dx *S;
S=Init_List();
DataType e;
cout<<"按从高指数到低指数，输入一元多项式的系数和指数；"<<endl;
for(int i=0;i<n;i++)
{
cout<<"指数：";
cin>>e.zhi;
if((S->length-1>=0&&e.zhi>=S->data[S->length-1].zhi)||e.zhi<0)
{
i--;
cout<<"输入指数大于前一项错误请重输或小于0！"<<endl;
continue;
}
cout<<"系数：";
cin>>e.xi;
In_list(S,e);
}
return S;
}
void print(Dx *S)
{
for(int i=0;ilength;i++)
{
if(i>0&&S->data[i].xi>=0)
cout<<"+";
cout<data[i].xi<<"X^"<data[i].zhi;
}
cout<<endl;
}
PDx Add(Dx *S1,Dx *S2)
{
Dx *S3;
S3=Init_List();
for(int x=0;xlength;x++)
{
S3->length++;
S3->data[S3->length-1]=S1->data[x];
}
for(int i=0;ilength;i++)
{ for(int j=0;jlength;j++)
{
if(S2->data[i].zhi==S3->data[j].zhi)
{
S3->data[j].xi+=S2->data[i].xi;
break;
}
else if(S2->data[i].zhi>S3->data[j].zhi)
{
Insert_list(S3,j,S2->data[i]);
break;
}
}
if(S2->data[i].zhidata[S3->length-1].zhi)
{
In_list(S3,S2->data[i]);
}
}
return S3;
}
PDx Sub(Dx *S1,Dx *S2)//S1-S2
{
Dx *S3;
S3=Init_List();
DataType e;
for(int x=0;xlength;x++)
{
S3->length++;
S3->data[S3->length-1]=S1->data[x];
}
for(int i=0;ilength;i++)
{ for(int j=0;jlength;j++)
{
if(S2->data[i].zhi==S3->data[j].zhi)
{
S3->data[j].xi-=S2->data[i].xi;
if(S3->data[j].xi==0)
Delete_list(S3,j+1);
break;
}
else if(S2->data[i].zhi>S3->data[j].zhi)
{
e=S2->data[i];
e.xi=-1*e.xi;
Insert_list(S3,j,e);
break;
}
}
if(S2->data[i].zhidata[S3->length-1].zhi)
{
e=S2->data[i];
e.xi=-1*e.xi;
In_list(S3,e);
}
}
return S3;
}
PDx Bin(Dx *S1,Dx *S2)
{
Dx *S3;
S3=Init_List();
DataType e,a;
a.xi=0;
a.zhi=0;
In_list(S3,a);
for(int i=0;ilength;i++)
for(int j=0;jlength;j++)
{
e.xi=S1->data[i].xi*S2->data[j].xi;
e.zhi=S1->data[i].zhi*S2->data[j].zhi;
for(int k=0;klength;k++)
{
if(e.zhi==S3->data[k].zhi)
{
S3->data[k].xi+=S2->data[j].xi;
break;
}
else if(e.zhi>S3->data[k].zhi)
{
Insert_list(S3,k,e);
break;
}
if(S3->length-2>=0&&e.zhidata[S3->length-2].zhi)
{
Insert_list(S3,S3->length-1,e);
}
}
}
return S3;
}

int _tmain(int argc, _TCHAR* argv[])
{
Dx *S1,*S2,*S3,*S4,*S5;
int i,j;
cout<<"要录入的1多项式项数:";
cin>>i;
S1=Luru(i);
cout<<"要录入的2多项式项数:";
cin>>j;
S2=Luru(j);
S3=Add(S1,S2);
S4=Sub(S1,S2);
S5=Bin(S1,S2);
cout<<"第一个多项式:"<<endl;
print(S1);
cout<<"第二个多项式:"<<endl;
print(S2);
cout<<"两多项式的和:"<<endl;
print(S3);
cout<<"两多项式的差"<<endl;
print(S4);
cout<<"两多项式的积"<<endl;
print(S5);
return 0;
}

给你其实是在害你，给你知识点，如果还不会再来问我
　线性代数的学习切入点：线性方程组。换言之，可以把线性代数看作是在研究线性方程组这一对象的过程中建立起来的学科。
　　线性方程组的特点：方程是未知数的一次齐次式，方程组的数目s和未知数的个数n可以相同，也可以不同。
　　关于线性方程组的解，有三个问题值得讨论：
　　（1）、方程组是否有解，即解的存在性问题；
　　（2）、方程组如何求解，有多少个解；
　　（3）、方程组有不止一个解时，这些不同的解之间有无内在联系，即解的结构问题。
　　高斯消元法，最基础和最直接的求解线性方程组的方法，其中涉及到三种对方程的同解变换：
　　（1）、把某个方程的k倍加到另外一个方程上去；
　　（2）、交换某两个方程的位置；
　　（3）、用某个常数k乘以某个方程。我们把这三种变换统称为线性方程组的初等变换。
　　任意的线性方程组都可以通过初等变换化为阶梯形方程组。
　　由具体例子可看出，化为阶梯形方程组后，就可以依次解出每个未知数的值，从而求得方程组的解。
　　对方程组的解起决定性作用的是未知数的系数及其相对位置，所以可以把方程组的所有系数及常数项按原来的位置提取出来，形成一张表，通过研究这张表，就可以判断解的情况。我们把这样一张由若干个数按某种方式构成的表称为矩阵。
　　可以用矩阵的形式来表示一个线性方程组，这至少在书写和表达上都更加简洁。
　　系数矩阵和增广矩阵。
　　高斯消元法中对线性方程组的初等变换，就对应的是矩阵的初等行变换。阶梯形方程组，对应的是阶梯形矩阵。换言之，任意的线性方程组，都可以通过对其增广矩阵做初等行变换化为阶梯形矩阵，求得解。
　　阶梯形矩阵的特点：左下方的元素全为零，每一行的第一个不为零的元素称为该行的主元。
　　对不同的线性方程组的具体求解结果进行归纳总结（有唯一解、无解、有无穷多解），再经过严格证明，可得到关于线性方程组解的判别定理：首先是通过初等变换将方程组化为阶梯形，若得到的阶梯形方程组中出现0=d这一项，则方程组无解，若未出现0=d一项，则方程组有解；在方程组有解的情况下，若阶梯形的非零行数目r等于未知量数目n，方程组有唯一解，若r在利用初等变换得到阶梯型后，还可进一步得到最简形，使用最简形，最简形的特点是主元上方的元素也全为零，这对于求解未知量的值更加方便，但代价是之前需要经过更多的初等变换。在求解过程中，选择阶梯形还是最简形，取决于个人习惯。
　　常数项全为零的线性方程称为齐次方程组，齐次方程组必有零解。
　　齐次方程组的方程组个数若小于未知量个数，则方程组一定有非零解。
　　利用高斯消元法和解的判别定理，以及能够回答前述的基本问题（1）解的存在性问题和（2）如何求解的问题，这是以线性方程组为出发点建立起来的最基本理论。
　　对于n个方程n个未知数的特殊情形，我们发现可以利用系数的某种组合来表示其解，这种按特定规则表示的系数组合称为一个线性方程组（或矩阵）的行列式。行列式的特点：有n！项，每项的符号由角标排列的逆序数决定，是一个数。
　　通过对行列式进行研究，得到了行列式具有的一些性质（如交换某两行其值反号、有两行对应成比例其值为零、可按行展开等等），这些性质都有助于我们更方便的计算行列式。
　　用系数行列式可以判断n个方程的n元线性方程组的解的情况，这就是克莱姆法则。
　　总而言之，可把行列式看作是为了研究方程数目与未知量数目相等的特殊情形时引出的一部分内容

【问题描述】
编程实现一元多项式的加法计算。
【基本要求】
能用链表实现一元多项式的加法计算，并能打印出计算结果。
【所需知识】
（1）基本编程方法和程序设计知识。
（2）链表的理解和运算与运用。
【所用算法】
遍历算法和递归算法。
【操作平台】
Visual C++

#include<stdio.h>
#include<graphics.h>
#define MAX 100
typedef struct polynode
{ float coef;
int expn;
struct polynode *next;
}node;

node * create(void) /*指针函数，返回指针类型；用尾插法建立一元多项式的链表的函数*/
{
node *h,*r,*s;
float c;
int e;
h=(node *)malloc(sizeof(node)); /*建立多项式的头结点，为头结点分配存储空间*/
r=h; /*r指针始终动态指向链表的当前表尾，以便于做尾插入，其初值指向头结点*/
printf("coef:");
scanf("%f",&c); /*输入系数*/
printf("expn: ");
scanf("%d",&e); /*输入指数*/
while(c!=0.0) /*输入系数为0时，表示多项式的输入结束*/
{
s=(node *)malloc(sizeof(node)); /*申请新结点*/
s->coef=c; /*申请新结点后赋值*/
s->expn=e; /*申请新结点后赋值*/
r->next=s; /*做尾插，插入新结点*/
r=s; /*r始终指向单链表的表尾*/
printf("coef:");
scanf("%f",&c);
printf("expn: ");
scanf("%d",&e);
}
r->next=NULL; /*将表的最后一个结点的next置NULL，以示表结束*/
return(h);
}

void polyadd(node *pa, node *pb) /*一元多项式相加函数，用于将两个多项式相加，
然后将和多项式存放在多项式pa中，并将多项式pb删除*/
{
node *p,*q,*pre,*temp;
int sum;
p=pa->next; /*令p和q分别指向pa和pb多项式链表中的第一个结点*/
q=pb->next;
pre=pa; /*位置指针，指向和多项式pa*/
while(p!=NULL&&q!=NULL) /*当两个多项式均未扫描结束时，执行以下操作*/
{
if(p->expn<q->expn) /*若p指向的多项式指数小于q指的指数*/
{
pre->next=p; /*将p结点加入到和多项式中*/
pre=pre->next;
p=p->next;
}
if(p->expn==q->expn) /*若指数相等，则相应的系数相加*/
{
sum=p->coef+q->coef;
if(sum!=0)
{
p->coef=sum;
pre->next=p;pre=pre->next;p=p->next;
temp=q;q=q->next;free(temp);
}
else /*如果系数和为零，则删除结点p与q，并将指针指向下一个结点*/
{
temp=p->next;free(p);p=temp;
temp=q->next;free(q);q=temp;
}
}
if (q->expn<p->expn)
{
pre->next=q; /*将q结点加入到和多项式中*/
pre=pre->next;
q=q->next;
}
}
if(p!=NULL) /*多项式A中还有剩余，则将剩余的结点加入到和多项式中*/
pre->next=p;
else /*否则将B的结点加入到和多项式中*/
pre->next=q;
}

void print(node * p) /*输出函数，打印出一元多项式*/
{
while(p->next!=NULL)
{
p=p->next;
printf(" %f*x^%d",p->coef,p->expn);
}
}

void calculate() /*给多项式赋值并计算*/
{ float cal=1.0,mid=0.0,las;
int j;
float num, x;
int i=0;
float later=0.0;
int e[MAX];float c[MAX];
printf("Please input num:"); /*输入常数的值*/
scanf("%f",&num);
printf("Please input x:"); /*输入未知数X的值*/
scanf("%f",&x);
printf("Please input e[0]:"); /*输入数组的初值以判断是否循环*/
scanf("%d",&e[0]);
printf("Please input c[0]:");
scanf("%f",&c[0]);
while(e[i]!=0 && c[i]!=0.0 ) /*此循环用于多项式的计算*/
{ cal=1;
for(j=0;j<e[i];j++) /*表示出X的几次方*/
{
cal=cal*x;
}
i++;
mid=cal*c[i-1]; /*表示出单项*/
later+=mid;
printf("Please input e[%d] and c[%d] :",i,i);
scanf("%d%f",&e[i],&c[i]);

}
las=later+num; /*表示出完整的多项式*/
printf("The Result is :\n");
printf("%f",las); /*最终的计算结果*/
sleep(3);

}
void main()
{
node * pa,* pb,*pc,*p,*q,*pre;
int driver=VGA,mode=VGAHI;
initgraph(&driver,&mode,"c:\\tc ");
setbkcolor(BLUE);
setcolor(RED);
printf("Welcome,Let's go!\n");
printf("Next, you will see the process of computing !");
printf("\nPlease input the coef and expn of pa:\n");
pa=create(); /*调用建立链表函数，创建多项式A*/
print(pa);
printf("\nPlease input the coef and expn of pb:\n");
pb=create(); /*同理，创建B*/
print(pb);
p=pa->next; /*以下代码用于排序*/
pa->next=NULL;
while(p!=NULL)
{
if(pa->next==NULL)
{
pa->next=p;p=p->next;
pa->next->next=NULL;
}
else
{ pre=pa;q=pre->next;
while(q!=NULL && p->expn>q->expn)
{
pre=q;q=q->next;
}
q=p->next;
p->next=pre->next;
pre->next=p;
p=q;

}
}
printf("\nthe first ordered one:\n");print(pa); /*输出排序后的pa*/
p=pb->next; /*以下代码用于给pb排序*/
pb->next=NULL;
while(p!=NULL)
{
if(pb->next==NULL)
{
pb->next=p;p=p->next;
pb->next->next=NULL;
}
else
{ pre=pb;q=pre->next;
while(q!=NULL && p->expn>q->expn)
{
pre=q;q=q->next;
}
q=p->next;
p->next=pre->next;
pre->next=p;
p=q;

}
}
printf("\nthe second ordered one:\n");print(pb); /*输出排序后的pb*/
printf("\nSum of the polys is:\n");
polyadd(pa,pb); /*调用一元多项式相加函数*/
print(pa); /*调用输出函数，打印结果*/
printf("\n");
setbkcolor(RED);
calculate(); /*调用计算多项式值的函数*/
}

【编后总结】
本程序在逻辑设计，详细设计，程序编码和程序调试阶段时本来都城有设计save()保存函数，和load()下载函数，分别用来保存创建的多项式，和下载其它需计算的多项式数据，这样这个系统才能更加实用，void createadj()原来的函数原型为arcnode *createdj()函数中用链表结构把adjmatrix[][]的数据都保存其中，这样就能实现数据的保存，但随之要把Dijkstra中的adjmatrix[][]转换成用arcnode 指针的形式进行表示，因为只有这样，下载后的数据才能使用。但在最后的调试阶段中，发现dijkstra无法运行，但又苦于无法用save()函数保存adjmatrix[][],最后只放弃save()和load()函数，在 main()主函数中初始化该算式。从这次程序设计中我看到自己的不足之处，今后要更努力的学习和掌握好数据结构程序设计的知识。

#include "stdafx.h"
#include "iostream"
using namespace std;
#define MAXSIZE 10
typedef struct
{
int xi;
int zhi;
}DataType;
typedef struct node
{
DataType data[MAXSIZE];
int length;
}Dx,*PDx;
PDx Init_List()
{
Dx *S;
S=(Dx *)malloc(sizeof(Dx));
if(S)
S->length=0;
return S;
}
int Empty(Dx *S)
{
if(S->length==0)
return 1;
else return 0;
}
int In_list(Dx *S,DataType a)//建立多项式存储结构
{
if(S&&S->length<MAXSIZE)
{
S->length++;
S->data[S->length-1]=a;
return 1;
}
else return 0;
}
int Insert_list(Dx *S,int j,DataType e)//插入
{
if(S&&S->length<MAXSIZE)
{
S->length++;
for(int i=S->length-1;i>j;i--)
S->data[i]=S->data[i-1];
S->data[j]=e;
return 1;
}
else return 0;
}
int Delete_list(Dx *S,int m)//m就是数组下标
{
if(!S)
{
cout<<"多项式不存在！"<<endl;
return -1;
}
if(m<1||m>S->length)
{
cout<<"删除位置不合法！"<<endl;
return 0;
}
for(int j=m;j<S->length;j++)
S->data[j-1]=S->data[j];
S->length--;
return 1;
}
PDx Luru(int n)//录入多项式，并存储起来,n为多项式的项数！
{
Dx *S;
S=Init_List();
DataType e;
cout<<"按从高指数到低指数，输入一元多项式的系数和指数；"<<endl;
for(int i=0;i<n;i++)
{
cout<<"指数：";
cin>>e.zhi;
if((S->length-1>=0&&e.zhi>=S->data[S->length-1].zhi)||e.zhi<0)
{
i--;
cout<<"输入指数大于前一项错误请重输或小于0！"<<endl;
continue;
}
cout<<"系数：";
cin>>e.xi;
In_list(S,e);
}
return S;
}
void print(Dx *S)
{
for(int i=0;i<S->length;i++)
{
if(i>0&&S->data[i].xi>=0)
cout<<"+";
cout<<S->data[i].xi<<"X^"<<S->data[i].zhi;
}
cout<<endl;
}
PDx Add(Dx *S1,Dx *S2)
{
Dx *S3;
S3=Init_List();
for(int x=0;x<S1->length;x++)
{
S3->length++;
S3->data[S3->length-1]=S1->data[x];
}
for(int i=0;i<S2->length;i++)
{ for(int j=0;j<S3->length;j++)
{
if(S2->data[i].zhi==S3->data[j].zhi)
{
S3->data[j].xi+=S2->data[i].xi;
break;
}
else if(S2->data[i].zhi>S3->data[j].zhi)
{
Insert_list(S3,j,S2->data[i]);
break;
}
}
if(S2->data[i].zhi<S3->data[S3->length-1].zhi)
{
In_list(S3,S2->data[i]);
}
}
return S3;
}
PDx Sub(Dx *S1,Dx *S2)//S1-S2
{
Dx *S3;
S3=Init_List();
DataType e;
for(int x=0;x<S1->length;x++)
{
S3->length++;
S3->data[S3->length-1]=S1->data[x];
}
for(int i=0;i<S2->length;i++)
{ for(int j=0;j<S3->length;j++)
{
if(S2->data[i].zhi==S3->data[j].zhi)
{
S3->data[j].xi-=S2->data[i].xi;
if(S3->data[j].xi==0)
Delete_list(S3,j+1);
break;
}
else if(S2->data[i].zhi>S3->data[j].zhi)
{
e=S2->data[i];
e.xi=-1*e.xi;
Insert_list(S3,j,e);
break;
}
}
if(S2->data[i].zhi<S3->data[S3->length-1].zhi)
{
e=S2->data[i];
e.xi=-1*e.xi;
In_list(S3,e);
}
}
return S3;
}
PDx Bin(Dx *S1,Dx *S2)
{
Dx *S3;
S3=Init_List();
DataType e,a;
a.xi=0;
a.zhi=0;
In_list(S3,a);
for(int i=0;i<S1->length;i++)
for(int j=0;j<S2->length;j++)
{
e.xi=S1->data[i].xi*S2->data[j].xi;
e.zhi=S1->data[i].zhi*S2->data[j].zhi;
for(int k=0;k<S3->length;k++)
{
if(e.zhi==S3->data[k].zhi)
{
S3->data[k].xi+=S2->data[j].xi;
break;
}
else if(e.zhi>S3->data[k].zhi)
{
Insert_list(S3,k,e);
break;
}
if(S3->length-2>=0&&e.zhi<S3->data[S3->length-2].zhi)
{
Insert_list(S3,S3->length-1,e);
}
}
}
return S3;
}

int _tmain(int argc, _TCHAR* argv[])
{
Dx *S1,*S2,*S3,*S4,*S5;
int i,j;
cout<<"要录入的1多项式项数:";
cin>>i;
S1=Luru(i);
cout<<"要录入的2多项式项数:";
cin>>j;
S2=Luru(j);
S3=Add(S1,S2);
S4=Sub(S1,S2);
S5=Bin(S1,S2);
cout<<"第一个多项式:"<<endl;
print(S1);
cout<<"第二个多项式:"<<endl;
print(S2);
cout<<"两多项式的和:"<<endl;
print(S3);
cout<<"两多项式的差"<<endl;
print(S4);
cout<<"两多项式的积"<<endl;
print(S5);
return 0;
}

---

礼县13235292772： 数据结构课程设计顺序结构、动态链表结构下的一元多项式加法的实现.(难度**) 设有一元多项式Am(x)和Bn(x). Am(x)=A0+A1x1+A2x2+A3x3+… +Amxm ... - ？
益罗信徕：[答案] void Poly(LNode *&p) { LNode *q = p; if (p !=NULL) { if (p -> data.exp == 0){ q = p->next; delete p; p = q; // 修改表头指针 } while(q != NULL){ q -> data.coef *= q -> data.exp; q -> data.exp--; q = q -> next; } } }

礼县13235292772： 数据结构课程设计 -- 一元多项式计算 - ？
益罗信徕： #include typedef struct polynode { int coef; //多项式的系数 int exp; //指数 struct polynode *next; }node; node *create() //用尾插法建立一元多项式的链表 { node *h,*r,*s; int c,e; h=(node*)malloc(sizeof(node)); r=h; printf(＂coef:＂); scanf(＂%d＂,...

礼县13235292772： 数据结构课程设计(C语言版) 一元稀疏多项式的运算 - ？
益罗信徕： 数据关系:R=约定a1为栈底,an 为栈顶.基本操作:Push(&s,e) 初始条件:栈s已经存在.操作结果:插入元素e为新的栈顶元素 Pop(&s,&e) 初始条件:栈s已经存在且非空. 操作结果:删除s的栈顶元素,并用e返回其值

礼县13235292772： 数据结构课程设计报告 - ？
益罗信徕： 1、一元稀疏多项式相加详细设计4.1 程序头的设计: #include<stdio.h> #include<malloc.h> typedef struct pnode {int coef;/*系数 */ int exp;/*指数 */ struct pnode *next;/*下一个指针*/ }pnode;4.2 用头插法生成一个多项式,系数和...

礼县13235292772： 数据结构一元多项式的代数运算 - ？
益罗信徕： //多项式相加(用单链表实现,用尾插法建表,用墨守成连线法求新的多项式) #include<stdio.h> #include<stdlib.h> typedef struct LNode //单链表的结构 {int coef,exp;struct LNode *next; }LNode,*LinkList;void InitList(LinkList &L) //单链表的初始...

礼县13235292772： 数据结构 一元多项式相乘的代码? - ？
益罗信徕： 这是数组实现,别人写的. #include void mul(int a[],int b[],int w) {int shi[40]; int q,k,p,l; for ( k=0;k<40;k++) {shi[k]=0;} for( q=w;q>=0;q--) {for( p=w;p>=0;p--) { shi[q+p]=shi[q+p]+a[q]*b[p]; } } printf(＂\np(x)*q(x) = ＂); for( l=2*w;l>=0;l--) { printf(＂%dx^%d + ...

礼县13235292772： 数据结构.c语言版.一元多项式的计算要求,对高次多项式进行加减运算,并输出运算结果.要求用链表实现. 功能;1多项式的表示2多项式的加减运算3... - ？
益罗信徕：[答案] 高二数学里有这个例子 排列组合里面的

礼县13235292772： 数据结构课程设计作业 - ？
益罗信徕： polynomal.h-- #include<iostream.h> #include<stdio.h> #include＂math.h＂ struct Term { float coef; int exp; Term *link; Term(float c,int e,Term *next=NULL) { coef=c; exp=e; link=next; } Term *InsertAfter(float c,int e); friend ostream& operator<<(...

礼县13235292772： 设计一个一元多项式简单的计算器(数据结构C语言版)急 - ？
益罗信徕： 除以上功能外,还有乘法和除法的计算和导数计算呢.这是我以前做的数据结构课程设计.希望能帮上你的忙.#include<stdio.h>#include<malloc.h> typedef struct Polynomial{ float coef; int expn; struct Polynomial *next; }*Polyn,Polynomial; //Polyn...

礼县13235292772： 数据结构中图的建立及输出的课程设计 - ？
益罗信徕： 1、一元稀疏多项式相加 详细设计4.1 程序头的设计: #include #include typedef struct pnode {int coef;/*系数 */ int exp;/*指数 */ struct pnode *next;/*下一个指针*/ }pnode;4.2 用头插法生成一个多项式,系数和指数输入0时退出输入 pnode * ...