c语言一元多项式的乘法

A. 求用C语言编写求两个一元多项式相乘的代码

你提的这个要求实在是太自高了。你的这个大作业肯定是不会有人满足你的。因为从编写程序的角度上讲，使用任何一种编程语言编写带有一定复杂功能的任何程序，实际本质上都是一项艰苦的脑力劳动。即：除了编写程序之外，更多的时间和精力是需要放在调试程序上面的。
另外，你的要求中涉及到在编程过程中需要用到的很多计算机软件的理论知识。例如：数据结构和算法的设计（例如：链表的创建、排序等）、整个程序总体的设计风格、以及即使你在集成编程环境下面录入完全部的程序源代码，但是程序肯定是必须要经过一系列的不断调试（例如：在可疑的语句处设置断点、单步跟踪等）、编译、链接，直到运行出最终的正确结果。
故你的这个 C 语言大作业，别的任何人无法帮助你实现你的程序功能，只能够依靠自己的刻苦努力来完成它了。

B. C语言的一元多项式相乘问题,高手救急!

#include "stdio.h"
#include "alloc.h"
#include "conio.h"
typedef struct node
{ int e,c;
struct node *next;
}PN;
PN *createLink()
{ int n;
PN *head, *p;
p=head=(PN*)malloc(sizeof(PN));
printf("n=");
scanf("%d",&n);
while(n)
{ p->next=(PN*)(PN*)malloc(sizeof(PN));
p=p->next;
printf("c,e:");
scanf("%d%d",&p->c,&p->e);
n--;
}
p->next=NULL;
return head;
}
void printLink(PN *h)
{ PN *p=h->next;
while(p)
{ printf("(%d,%d) ", p->c, p->e);
p=p->next;
}
printf("\n");
}
void freeLink(PN *h)
{ PN *p=h;
while(p)
{ h=h->next;
free(p);
p=h;
}
}
PN *add(PN *ha, PN *hb)
{ PN *hc,*pc,*pa=ha->next,*pb=hb->next;
int c,e;
hc=pc=(PN*)malloc(sizeof(PN));
while( pa || pb )
{ if(pa&&(pb==NULL||pa->e<pb->e))
{ e=pa->e;
c=pa->c;
pa=pa->next;
}
else if(pb&&(pa==NULL||pb->e<pa->e))
{ e=pb->e;
c=pb->c;
pb=pb->next;
}
else
{ e=pb->e;
c=pa->c+pb->c;
pb=pb->next;
pa=pa->next;
}
if(c)
{ pc->next=(PN*)malloc(sizeof(PN));
pc=pc->next;
pc->c=c;
pc->e=e;
}
}
pc->next=NULL;
return hc;
}
PN * onexmul(PN *pa, PN *hb)
{ PN *hc=(PN*)malloc(sizeof(PN)),*pc,*pb=hb->next;
pc=hc;
while(pb)
{ pc->next=(PN*)malloc(sizeof(PN));
pc=pc->next;
pc->c=pa->c*pb->c;
pc->e=pa->e+pb->e;
pb=pb->next;
}
pc->next=NULL;
return hc;
}
PN *mulxmul(PN *ha, PN *hb)
{ PN *hc=(PN*)malloc(sizeof(PN)), *t, *pa=ha->next;
hc->next=NULL;
while(pa)
{ t=onexmul(pa,hb);
hc=add(hc,t); /* hc=hc+t */
freeLink(t);
pa=pa->next;
}
return hc;
}

main()
{ PN *ha,*hb,*hc;
clrscr();
ha=createLink();
hb=createLink();
printLink(ha);
printLink(hb);

hc=add(ha,hb);
printLink(hc);
freeLink(hc);

hc=mulxmul(ha,hb);
printLink(hc);

freeLink(ha);
freeLink(hb);
freeLink(hc);
}

这个是可以的，你可以看看，里有也有加法。

C. C语言编写一元多项式相乘，求解！！

你提的这个要求实在是太高了。你的这个大作业肯定是不会有人满足你的。因为从编写程序的角度上讲，使用任何一种编程语言编写带有一定复杂功能的任何程序，实际本质上都是一项艰苦的脑力劳动。即：除了编写程序之外，更多的时间和精力是需要放在调试程序上面的。

另外，你的要求中涉及到在编程过程中需要用到的很多计算机软件的理论知识。例如：数据结构和算法的设计（例如：链表的创建、排序等）、整个程序总体的设计风格、以及即使你在集成编程环境下面录入完全部的程序源代码，但是程序肯定是必须要经过一系列的不断调试（例如：在可疑的语句处设置断点、单步跟踪等）、编译、链接，直到运行出最终的正确结果。

故你的这个 C 语言大作业，别的任何人无法帮助你实现你的程序功能，只能够依靠自己的刻苦努力来完成它了。

D. 如何用C语言实现两个一元多项式的相加和相乘

用链表存储
typedef struct node{
int xishu;
int cifang;
node *next;
}node;
输入的时候只输入多项式的系数和对应的乘方数

相加减的时候可以从一个链表的第一项开始，在第二个链表中查找同类项，如果有的话就系数相加，并从第二个链表中删除该项，指针后移，重复直到第一个链结束，然后把第二个链剩余链连在后边就好了~

乘法的时候从第一个链头开始，与第二个链的逐项系数相成，乘方相加，然后再后移指针，直至链尾

E. 怎么用C语言做一个一元多项式的程序

#include<stdio.h>
#include<windows.h>
voidre(intmax,intnumber);//判断符号输出
intmain()
{
intnumber[101]={0};//存放指数幂
intx1,x2;
intesc=1,max=0;
for(inti=0;esc==1;i++){
scanf("%d%d",&x1,&x2);
if(i==0){
max=x1;
}
if(x2!=0){
number[x1]+=x2;//同一个次幂的系数都存在数组的同一个位置
//printf("%d",number[x1]);
}
if(x1==0){//数据停止录入的指令
esc=0;
}
//printf("min=%d,max=%d
",min,max);
}
intn_number[101]={0};//存放指数幂
intn_max=0;
for(inti=0;esc==0;i++){
scanf("%d%d",&x1,&x2);
if(i==0){
n_max=x1;
}
if(x2!=0){
n_number[x1]+=x2;//同一个次幂的系数都存在数组的同一个位置
//printf("%d",number[x1]);
}
if(x1==0){//数据停止录入的指令
esc=1;
}
//printf("min=%d,max=%d
",min,max);
}
if(n_max>max){//整个if用于将两个多项式的系数传给其中最大幂指数较大的数组
for(inti=4;i>=0;i--){
if(number[i]!=0||n_number[i]!=0){
n_number[i]+=number[i];
//printf("n_number[%d]=%d
",i,n_number);
}
if(n_number[i]!=0){
intdata=n_number[i];
//printf("%d",n_number[i]);
re(i,data);
}
}
}else{
for(inti=100;i>=0;i--){
if(number[i]!=0||n_number[i]!=0){
number[i]+=n_number[i];
}
if(number[i]!=0){
intdata=number[i];
//printf("%d",number[i]);
re(i,data);
}
}
}
printf("
");
system("pause");
return0;
}
voidre(inti,intnumber)
{
if(number!=1){
printf("%d",number);//如果系数为1不输出系数，如果系数为-1输出负号
}elseif(number==-1){
printf("-");
}
if(i){//当指数不为0时输出x
printf("x");
}
if(i>1){//防止出现幂数为1的情况
printf("%d",i);
}
if(i>0&&number>0){//系数为负数时不输出+号
printf("+");
}
}

F. 求数据结构程序C语言版，计算任意两个一元多项式的加减乘法，输出结果多项式，要求实现多项式的插入和删除

struct poly
{
int cishu;//次方数
int xishu; //系数
};
/*在写加减乘除时：首先输入一个多项式其实就是一个结构体数组 每个数组元素由 次数和系数组成 排序（按照次数的大小顺序排序） 求出每个多项式的长度， 再 每个加减乘除函数里面的堆上分配一个新的结构体数组（malloc）以两者中最长的长度分配，加减乘除时先遍历长度大的再遍历长度小的 两个for循环OK!然后将剩下的再来一个循环一下剩下的没有合并同类项的，返回合并后的多项式...插入好说，删除也好说！这个代码量还有点不想写 */
typedef struct poly Polygon;
int Input(Polygon*);//输入函数返回输入多项式的长度
void sort(Polygon*);//排序
Polygon *Add(Polygon*,Polygon*);//加
Polygon* Minus(Ploygon*,Polygon*);//减
Polygon* Mul(Polygon*,Polygon*);//乘
Polygon* Div(Polygon*,Polygon*);//除
void Output(Polygon*);//输出
void Insert(Polygon*)//查入

G. 用C语言实现一元多项式相乘

#include<stdio.h>
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 + ",shi[l],l);
}
printf("0\n");
}
int main()
{
int i,j,k,m;
int x[20];
int y[20];
printf("请输入一元N次多项式的N：");
scanf("%d",&i);
for(j=0;j<=i;j++)
{
printf("P(x) %d次项系数:",j);
scanf("%d",&x[j]);
printf("Q(x) %d次项系数:",j);
scanf("%d",&y[j]);
}
printf("\nP(x) = ");
for (k=i;k>=0;k--)
{printf("%dX^%d + ",x[k],k);}
printf("0");
printf("\nQ(x) = ");
for (m=i;m>=0;m--)
{printf("%dX^%d + ",y[m],m);}
printf("0");
Mul(x,y,i);
}

H. 一元多项式的实现（C语言）

#define TURE 1
#define FALSE 0
#include<stdio.h>
#include<stdlib.h>
typedef struct
{
float coef;
int e;
}ElementType;
typedef struct node
{
ElementType data;
struct node *next;//这也是为什么要定义struct node 而非struct的原因
}Lnode,*LinkList;

int Head_CreatLinkList (LinkList &L,int n,ElementType a[])//头插法建立链表
{
int i;
LinkList head,p;
L=(LinkList)malloc(sizeof(Lnode));
L->next=NULL;
head=L;
for(i=0;i<n;i++)
{
p=(LinkList)malloc(sizeof(Lnode));
p->next=NULL;
p->data.coef=a[i].coef;
p->data.e=a[i].e;
head->next=p;
head=p;
}
return TURE;
}
int GetElement(LinkList L)
{
int m;
m=L->data.e;
//printf("%d",m);
return m;
}
int Comp(int a,int b )
{
if(a>b)
return 1;
else if(a<b)
return -1;
else
return 0;
}
int Union_LinkList(LinkList &L1,LinkList &L2,LinkList &L3)
{
LinkList p1,p2,p3,flag1,flag2;//flag标记指针，用于删除L2中节点
p1=L1->next;
p2=L2->next;
L3=p3=L1;//L3改变将导致L1的改变，即最终L3和L1相同
while(p1&&p2)
{
switch(Comp(GetElement( p1),GetElement( p2)))
{
case -1:
{
p3->next=p1;
p3=p1;
p1=p1->next;
break;
}
case 1:
{
p3->next=p2;
p3=p2;
p2=p2->next;
break;
}
case 0:
{
p1->data.coef=p1->data.coef+p2->data.coef;
if(p1->data.coef==0)
{
flag1=p1;
p1=p1->next;
free(flag1);
}
flag2=p2;
p2=p2->next;
free(flag2);
break;
}
}
}
p3->next=p1?p1:p2;
free(L2);
return TURE;
}

int Display_LinkList(LinkList L)
{
LinkList p;
p=L;
if(!p)
return FALSE;

while(p->next)
{
p=p->next;
printf("[%f%, %d]\t",p->data.coef,p->data.e);
}
printf("\n");
return TURE;

}

void main()
{
LinkList a,b,c;
ElementType a1[6]={{1,1},{2,7},{3,3},{4,4},{5,9},{1,10}};
ElementType a2[4]={{-1,1},{2,7},{3,8},{-5,9}};
Head_CreatLinkList (a,6,a1);
Head_CreatLinkList (b,4,a2);

Display_LinkList(a);
Display_LinkList(b);
Union_LinkList(a,b,c);
Display_LinkList(c);

}
这是自己以前写的一个多项式加法的程序，现在也没检查了，希望你自己好好调试一下，至于减法和除法，只要加一点吧。希望对你有帮助

I. 求C语言一元多项式的运算的代码

#include <stdio.h>
#include <stdlib.h>
#define SHI sizeof(struct oxiangshi)
#define NULL 0
struct oxiangshi
{int xishu,shu;
struct oxiangshi*next;
};

struct oxiangshi*create()
{struct oxiangshi*head,*p1,*p2;
int n;
n=0;
head=NULL;
p2=NULL;
p1=NULL;
p1=(struct oxiangshi*)malloc(SHI);
scanf("%d %d",&p1->xishu,&p1->shu);
while(p1->xishu!=NULL)
{++n;
if(n==1){head=p1;p2=p1;}
else{p2->next=p1;p2=p1,p2->next=NULL;}
p1=(struct oxiangshi*)malloc(SHI);
scanf("%d %d",&p1->xishu,&p1->shu);
p1->next=NULL;
}
free(p1);
return (head);
}

void paixu(struct oxiangshi*head)
{struct oxiangshi*p1,*p2;
int t=0;
p1=head;
p2=head;
for( ; ;p1=p1->next)
{ if(p1->next==NULL)break;
for(p2=p1->next; ;p2=p2->next)
{ if(p1->shu>p2->shu)
{ t=p1->shu;
p1->shu=p2->shu;
p2->shu=t;

t=p1->xishu;
p1->xishu=p2->xishu;
p2->xishu=t;
}

if(p2->next==NULL)break;
}
}
}

struct oxiangshi*add(struct oxiangshi*head1,struct oxiangshi*head2)
{struct oxiangshi*p1,*p2,*s,*p3,*head3;
int n=1;
p1=head1;
p2=head2;
head3=NULL;
p3=NULL;
while(p1!=NULL&&p2!=NULL)
{s=(struct oxiangshi*)malloc(SHI);
++n;
if(n==1) head3=s;
if(p1->shu>p2->shu)
{s->shu=p2->shu;
s->xishu=p2->xishu;
p2=p2->next;
}
else if(p1->shu<p2->shu)
{s->shu=p1->shu;
s->xishu=p1->xishu;
p1=p1->next;
}
else
{s->shu=p1->shu;
s->xishu=p1->xishu+p2->xishu;
p1=p1->next;
p2=p2->next;
}
p3->next=s;
p3=s;

}
p3->next=NULL;
if(p1!=NULL)
p3->next=p1;
if(p2!=NULL)
p3->next=p2;
return (head3);
}

struct oxiangshi* minus(struct oxiangshi*head1,struct oxiangshi*head2)
{struct oxiangshi*p2;
p2=head2;
while(p2!=NULL)
{p2->xishu=(-1)*p2->xishu;
p2=p2->next;
}
return (add(head1,head2));
}

struct oxiangshi* multiply(struct oxiangshi*px,struct oxiangshi*py)
{ int n=0,i=0,j=0;
struct oxiangshi*heada,*headb,*pa,*pb,*lasta,*lastb,*p2,*p1;
p1=heada=headb=pa=pb=lasta=lastb=NULL;
p2=py;

while (p2!=NULL)
{n++;
if(n==1)
{ p1=px;
while(p1!=NULL)
{i++;
pa=(struct oxiangshi*)malloc(SHI);
if(i==1) heada=pa;
else lasta->next=pa;
lasta=pa;
pa->xishu=p1->xishu*p2->xishu;
pa->shu=p1->shu+p2->shu;
pa->next=NULL;
p1=p1->next;
}
}
else
{ p1=px;
while(p1!=NULL)
{j++;
pb=(struct oxiangshi*)malloc(SHI);
if(j==1) headb=pb;
else lastb->next=pb;
lastb=pb;
pb->xishu=p1->xishu*p2->xishu;
pb->shu=p1->shu+p2->shu;
pb->next=NULL;
p1=p1->next;
}

}
p2=p2->next;
if(n!=1)heada=add(heada,headb);
}
return(heada);

}

void print (struct oxiangshi*head3)
{struct oxiangshi*p3;
p3=head3;

do
{ if(p3->shu==0)
{printf("%d",p3->xishu);
p3=p3->next;
continue;
}
else if(p3==head3)
{printf("%dx%d",p3->xishu,p3->shu);
p3=p3->next;
continue;
}
else if(p3->xishu<0)
printf("%dx%d",p3->xishu,p3->shu);
else if(p3->xishu>0)
printf("+%dx%d",p3->xishu,p3->shu);
p3=p3->next;
}while(p3!=NULL);
printf("\n\n");
}

void main()
{struct oxiangshi*p1,*p2,*p3;
int c=0;char d;
do
{

printf("please input A:\n");
p1=create();
paixu(p1);
printf("\nthe A is:");
print(p1);

printf("please input B:\n");
p2=create();
paixu(p2);
printf("\nthe B is:");
print(p2);

printf("\n please choice :\n");
printf("*********************************\n");
printf("1.add 2.minu 3.multiply\n");
printf("*********************************\n");
scanf("%d",&c);
switch(c)
{case 1:p3=add(p1,p2);break;
case 2:p3=minus(p1,p2);break;
case 3:p3=multiply(p1,p2);break;
default:printf("\nerror");

}
printf("\nthe result is :");
print(p3);
printf("do you still have anything to do?(y/n):\n");
scanf("%c",&d);
getchar();
clrscr();

}while(d!='n'&&d!='N');

}

J. C语言，多项式相乘

#include<stdio.h>
#include<stdlib.h>

typedefstructnode{
	intcoefficient,power;
	structnode*next;
}term;

term*new_term(intcoefficient,intpower){
	term*t=(term*)malloc(sizeof(term));
	t->next=NULL;
	t->coefficient=coefficient;
	t->power=power;
	returnt;
}

voidfree_term(term*t){
	free(t);
}

typedefstructlist{
	termhead;
}polynomial;

voidinit_polynomial(polynomial*p){
	p->head.next=NULL;
}

voidclear_polynomial(polynomial*p){
	term*t=p->head.next;
	term*del;
	while(t!=NULL){
		del=t;
		t=t->next;
		free_term(del);
	}
	p->head.next=NULL;
}

voidinsert_polynomial(polynomial*p,term*t){
	t->next=p->head.next;
	p->head.next=t;
}

voidsort(polynomial*p){
	term*t;
	term*next;
	intfinish=0,temp;
	while(!finish){
		finish=1;
		t=p->head.next;
		while(t!=NULL){
			next=t->next;
			if(next!=NULL){
				if(t->power<next->power){
					temp=t->coefficient;
					t->coefficient=next->coefficient;
					next->coefficient=temp;
					temp=t->power;
					t->power=next->power;
					next->power=temp;
					finish=0;
				}
			}
			t=next;
		}
	}
}

voidcombine(polynomial*p){
	term*t=p->head.next;
	term*next;
	while(t!=NULL){
		next=t->next;
		if(next!=NULL&&next->power==t->power){
			t->coefficient+=next->coefficient;
			t->next=next->next;
			free_term(next);
		}
		else{
			t=next;
		}
	}
}

voidmultiply(polynomial*p1,polynomial*p2,polynomial*p3){
	term*t1=p1->head.next;
	term*t2;
	clear_polynomial(p3);
	init_polynomial(p3);
	while(t1!=NULL){
		t2=p2->head.next;
		while(t2!=NULL){
			insert_polynomial(p3,new_term(t1->coefficient*t2->coefficient,t1->power+t2->power));
			t2=t2->next;
		}
		t1=t1->next;
	}
	sort(p3);
	combine(p3);
}

voidinput(polynomial*p){
	intcoef,power;
	charc;
	init_polynomial(p);
	while(true){
		scanf("%d%d",&coef,&power);
		insert_polynomial(p,new_term(coef,power));
		c=getchar();
		if(c=='
')break;
	}
	sort(p);
	combine(p);
}

voidoutput(polynomial*p){
	term*t=p->head.next;
	while(t!=NULL){
		printf("%d%d",t->coefficient,t->power);
		t=t->next;
	}
}

intmain(){
	inti;
	polynomialp[3];
	for(i=0;i<3;i++){
		init_polynomial(&p[i]);
	}
	for(i=0;i<2;i++){
		input(&p[i]);
	}
	multiply(&p[0],&p[1],&p[2]);
	output(&p[2]);
}