急解一个数据结构的题（C语言）

Question

题目如下：
两个一元多项式相乘的算法
M（x)=A(x)*B(x)
=A(x)*[b1X^e1+b2X^e2+...+bnX^en]
也就是A（x)和B(x)都个是一个一元多项式。
例如：M(x)=A(x)*B(x)
=(2x^2+3x^3+4x^4)*(5x^2+6x^3+7x^4)
可以利用两个一元多项式相加的算法来实现，因为乘法运算可以分解为一系列的加法运算。

答案满意的话我再给200分，大哥大姐些，速度啊~急需哦~~谢谢啦
准备拿来应付数据结构课程设计的，代码量不能太少啊

Answer 1

楼主真是太有缘了，我也正学数据结构，这是老师给我们提供的源代码，希望有用

Status MakeNode(Link *p,ElemType e)
{ /* 分配由p指向的值为e的结点，并返回OK；若分配失败。则返回ERROR */
*p=(Link)malloc(sizeof(LNode));
if(!*p)
return ERROR;
(*p)->data=e;
return OK;
}

void FreeNode(Link *p)
{ /* 释放p所指结点 */
free(*p);
*p=NULL;
}

Status InitList(LinkList *L)
{ /* 构造一个空的线性链表 */
Link p;
p=(Link)malloc(sizeof(LNode)); /* 生成头结点 */
if(p)
{
p->next=NULL;
(*L).head=(*L).tail=p;
(*L).len=0;
return OK;
}
else
return ERROR;
}

Status ClearList(LinkList *L)
{ /* 将线性链表L重置为空表，并释放原链表的结点空间 */
Link p,q;
if((*L).head!=(*L).tail)/* 不是空表 */
{
p=q=(*L).head->next;
(*L).head->next=NULL;
while(p!=(*L).tail)
{
p=q->next;
free(q);
q=p;
}
free(q);
(*L).tail=(*L).head;
(*L).len=0;
}
return OK;
}

Status DestroyList(LinkList *L)
{ /* 销毁线性链表L，L不再存在 */
ClearList(L); /* 清空链表 */
FreeNode(&(*L).head);
(*L).tail=NULL;
(*L).len=0;
return OK;
}

Status InsFirst(LinkList *L,Link h,Link s) /* 形参增加L,因为需修改L */
{ /* h指向L的一个结点，把h当做头结点，将s所指结点插入在第一个结点之前 */
s->next=h->next;
h->next=s;
if(h==(*L).tail) /* h指向尾结点 */
(*L).tail=h->next; /* 修改尾指针 */
(*L).len++;
return OK;
}

Status DelFirst(LinkList *L,Link h,Link *q) /* 形参增加L,因为需修改L */
{ /* h指向L的一个结点，把h当做头结点，删除链表中的第一个结点并以q返回。 */
/* 若链表为空(h指向尾结点)，q=NULL，返回FALSE */
*q=h->next;
if(*q) /* 链表非空 */
{
h->next=(*q)->next;
if(!h->next) /* 删除尾结点 */
(*L).tail=h; /* 修改尾指针 */
(*L).len--;
return OK;
}
else
return FALSE; /* 链表空 */
}

Status Append(LinkList *L,Link s)
{ /* 将指针s(s->data为第一个数据元素)所指(彼此以指针相链,以NULL结尾)的 */
/* 一串结点链接在线性链表L的最后一个结点之后,并改变链表L的尾指针指向新 */
/* 的尾结点 */
int i=1;
(*L).tail->next=s;
while(s->next)
{
s=s->next;
i++;
}
(*L).tail=s;
(*L).len+=i;
return OK;
}

Position PriorPos(LinkList L,Link p)
{ /* 已知p指向线性链表L中的一个结点，返回p所指结点的直接前驱的位置 */
/* 若无前驱，则返回NULL */
Link q;
q=L.head->next;
if(q==p) /* 无前驱 */
return NULL;
else
{
while(q->next!=p) /* q不是p的直接前驱 */
q=q->next;
return q;
}
}

Status Remove(LinkList *L,Link *q)
{ /* 删除线性链表L中的尾结点并以q返回，改变链表L的尾指针指向新的尾结点 */
Link p=(*L).head;
if((*L).len==0) /* 空表 */
{
*q=NULL;
return FALSE;
}
while(p->next!=(*L).tail)
p=p->next;
*q=(*L).tail;
p->next=NULL;
(*L).tail=p;
(*L).len--;
return OK;
}

Status InsBefore(LinkList *L,Link *p,Link s)
{ /* 已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之前， */
/* 并修改指针p指向新插入的结点 */
Link q;
q=PriorPos(*L,*p); /* q是p的前驱 */
if(!q) /* p无前驱 */
q=(*L).head;
s->next=*p;
q->next=s;
*p=s;
(*L).len++;
return OK;
}

Status InsAfter(LinkList *L,Link *p,Link s)
{ /* 已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之后， */
/* 并修改指针p指向新插入的结点 */
if(*p==(*L).tail) /* 修改尾指针 */
(*L).tail=s;
s->next=(*p)->next;
(*p)->next=s;
*p=s;
(*L).len++;
return OK;
}

Status SetCurElem(Link p,ElemType e)
{ /* 已知p指向线性链表中的一个结点，用e更新p所指结点中数据元素的值 */
p->data=e;
return OK;
}

ElemType GetCurElem(Link p)
{ /* 已知p指向线性链表中的一个结点，返回p所指结点中数据元素的值 */
return p->data;
}

Status ListEmpty(LinkList L)
{ /* 若线性链表L为空表，则返回TRUE，否则返回FALSE */
if(L.len)
return FALSE;
else
return TRUE;
}

int ListLength(LinkList L)
{ /* 返回线性链表L中元素个数 */
return L.len;
}

Position GetHead(LinkList L)
{ /* 返回线性链表L中头结点的位置 */
return L.head;
}

Position GetLast(LinkList L)
{ /* 返回线性链表L中最后一个结点的位置 */
return L.tail;
}

Position NextPos(Link p)
{ /* 已知p指向线性链表L中的一个结点，返回p所指结点的直接后继的位置 */
/* 若无后继，则返回NULL */
return p->next;
}

Status LocatePos(LinkList L,int i,Link *p)
{ /* 返回p指示线性链表L中第i个结点的位置，并返回OK，i值不合法时返回ERROR */
/* i=0为头结点 */
int j;
if(i<0||i>L.len)
return ERROR;
else
{
*p=L.head;
for(j=1;j<=i;j++)
*p=(*p)->next;
return OK;
}
}

Position LocateElem(LinkList L,ElemType e,Status (*compare)(ElemType,ElemType))
{ /* 返回线性链表L中第1个与e满足函数compare()判定关系的元素的位置， */
/* 若不存在这样的元素，则返回NULL */
Link p=L.head;
do
p=p->next;
while(p&&!(compare(p->data,e))); /* 没到表尾且没找到满足关系的元素 */
return p;
}

Status ListTraverse(LinkList L,void(*visit)(ElemType))
{ /* 依次对L的每个数据元素调用函数visit()。一旦visit()失败，则操作失败 */
Link p=L.head->next;
int j;
for(j=1;j<=L.len;j++)
{
visit(p->data);
p=p->next;
}
printf("\n");
return OK;
}

Status OrderInsert(LinkList *L,ElemType e,int (*comp)(ElemType,ElemType))
{ /* 已知L为有序线性链表，将元素e按非降序插入在L中。（用于一元多项式） */
Link o,p,q;
q=(*L).head;
p=q->next;
while(p!=NULL&&comp(p->data,e)<0) /* p不是表尾且元素值小于e */
{
q=p;
p=p->next;
}
o=(Link)malloc(sizeof(LNode)); /* 生成结点 */
o->data=e; /* 赋值 */
q->next=o; /* 插入 */
o->next=p;
(*L).len++; /* 表长加1 */
if(!p) /* 插在表尾 */
(*L).tail=o; /* 修改尾结点 */
return OK;
}

Status LocateElemP(LinkList L,ElemType e,Position *q,int(*compare)(ElemType,ElemType))
{ /* 若升序链表L中存在与e满足判定函数compare()取值为0的元素，则q指示L中 */
/* 第一个值为e的结点的位置，并返回TRUE；否则q指示第一个与e满足判定函数 */
/* compare()取值>0的元素的前驱的位置。并返回FALSE。（用于一元多项式） */
Link p=L.head,pp;
do
{
pp=p;
p=p->next;
}while(p&&(compare(p->data,e)<0)); /* 没到表尾且p->data.expn<e.expn */
if(!p||compare(p->data,e)>0) /* 到表尾或compare(p->data,e)>0 */
{
*q=pp;
return FALSE;
}
else /* 找到 */
{
*q=p;
return TRUE;
}
}

typedef struct LNode /* 结点类型 */
{
ElemType data;
struct LNode *next;
}LNode,*Link,*Position;

typedef struct LinkList /* 链表类型 */
{
Link head,tail; /* 分别指向线性链表中的头结点和最后一个结点 */
int len; /* 指示线性链表中数据元素的个数 */
}LinkList;

typedef LinkList polynomial;
#define DestroyPolyn DestroyList /* 与bo2-6.cpp中的函数同义不同名 */
#define PolynLength ListLength /* 与bo2-6.cpp中的函数同义不同名 */

Status OrderInsertMerge(LinkList *L,ElemType e,int(* compare)(term,term))
{ /* 按有序判定函数compare()的约定，将值为e的结点插入或合并到升序链表L的适当位置 */
Position q,s;
if(LocateElemP(*L,e,&q,compare)) /* L中存在该指数项 */
{
q->data.coef+=e.coef; /* 改变当前结点系数的值 */
if(!q->data.coef) /* 系数为0 */
{ /* 删除多项式L中当前结点 */
s=PriorPos(*L,q); /* s为当前结点的前驱 */
if(!s) /* q无前驱 */
s=(*L).head;
DelFirst(L,s,&q);
FreeNode(&q);
}
return OK;
}
else /* 生成该指数项并插入链表 */
if(MakeNode(&s,e)) /* 生成结点成功 */
{
InsFirst(L,q,s);
return OK;
}
else /* 生成结点失败 */
return ERROR;
}

int cmp(term a,term b) /* CreatPolyn()的实参 */
{ /* 依a的指数值<、=或>b的指数值，分别返回-1、0或+1 */
if(a.expn==b.expn)
return 0;
else
return (a.expn-b.expn)/abs(a.expn-b.expn);
}

void CreatPolyn(polynomial *P,int m) /* 算法2.22 */
{ /* 输入m项的系数和指数，建立表示一元多项式的有序链表P */
Position q,s;
term e;
int i;
InitList(P);
printf("请依次输入%d个系数，指数：\n",m);
for(i=1;i<=m;++i)
{ /* 依次输入m个非零项（可按任意顺序） */
scanf("%f,%d",&e.coef,&e.expn);
if(!LocateElemP(*P,e,&q,cmp)) /* 当前链表中不存在该指数项,cmp是实参 */
if(MakeNode(&s,e)) /* 生成结点并插入链表 */
InsFirst(P,q,s);
}
}

void PrintPolyn(polynomial P)
{ /* 打印输出一元多项式P */
Link q;
q=P.head->next; /* q指向第一个结点 */
printf(" 系数 指数\n");
while(q)
{
printf("%f %d\n",q->data.coef,q->data.expn);
q=q->next;
}
}

void AddPolyn(polynomial *Pa,polynomial *Pb) /* 算法2.23 */
{ /* 多项式加法:Pa=Pa+Pb,并销毁一元多项式Pb */
Position ha,hb,qa,qb;
term a,b;
ha=GetHead(*Pa);
hb=GetHead(*Pb); /* ha和hb分别指向Pa和Pb的头结点 */
qa=NextPos(ha);
qb=NextPos(hb); /* qa和qb分别指向Pa和Pb中当前结点（现为第一个结点） */
while(!ListEmpty(*Pa)&&!ListEmpty(*Pb)&&qa)
{ /* Pa和Pb均非空且ha没指向尾结点(qa!=0) */
a=GetCurElem(qa);
b=GetCurElem(qb); /* a和b为两表中当前比较元素 */
switch(cmp(a,b))
{
case -1:ha=qa; /* 多项式Pa中当前结点的指数值小 */
qa=NextPos(ha); /* ha和qa均向后移一个结点 */
break;
case 0: qa->data.coef+=qb->data.coef;
/* 两者的指数值相等,修改Pa当前结点的系数值 */
if(qa->data.coef==0) /* 删除多项式Pa中当前结点 */
{
DelFirst(Pa,ha,&qa);
FreeNode(&qa);
}
else
ha=qa;
DelFirst(Pb,hb,&qb);
FreeNode(&qb);
qb=NextPos(hb);
qa=NextPos(ha);
break;
case 1: DelFirst(Pb,hb,&qb); /* 多项式Pb中当前结点的指数值小 */
InsFirst(Pa,ha,qb);
ha=ha->next;
qb=NextPos(hb);
}
}
if(!ListEmpty(*Pb))
{
(*Pb).tail=hb;
Append(Pa,qb); /* 链接Pb中剩余结点 */
}
DestroyPolyn(Pb); /* 销毁Pb */
}

void AddPolyn1(polynomial *Pa,polynomial *Pb)
{ /* 另一种多项式加法的算法:Pa=Pa+Pb,并销毁一元多项式Pb */
Position qb;
term b;
qb=GetHead(*Pb); /* qb指向Pb的头结点 */
qb=qb->next; /* qb指向Pb的第一个结点 */
while(qb)
{
b=GetCurElem(qb);
OrderInsertMerge(Pa,b,cmp);
qb=qb->next;
}
DestroyPolyn(Pb); /* 销毁Pb */
}

void Opposite(polynomial Pa)
{ /* 一元多项式系数取反 */
Position p;
p=Pa.head;
while(p->next)
{
p=p->next;
p->data.coef*=-1;
}
}

void SubtractPolyn(polynomial *Pa,polynomial *Pb)
{ /* 多项式减法:Pa=Pa-Pb,并销毁一元多项式Pb */
Opposite(*Pb);
AddPolyn(Pa,Pb);
}

void MultiplyPolyn(polynomial *Pa,polynomial *Pb)
{ /* 多项式乘法:Pa=PaPb,并销毁一元多项式Pb */
polynomial Pc;
Position qa,qb;
term a,b,c;
InitList(&Pc);
qa=GetHead(*Pa);
qa=qa->next;
while(qa)
{
a=GetCurElem(qa);
qb=GetHead(*Pb);
qb=qb->next;
while(qb)
{
b=GetCurElem(qb);
c.coef=a.coef*b.coef;
c.expn=a.expn+b.expn;
OrderInsertMerge(&Pc,c,cmp);
qb=qb->next;
}
qa=qa->next;
}
DestroyPolyn(Pb); /* 销毁Pb */
ClearList(Pa); /* 将Pa重置为空表 */
(*Pa).head=Pc.head;
(*Pa).tail=Pc.tail;
(*Pa).len=Pc.len;
}

Answer 2

我的面向对象的课设，C++的，你看着改吧~（2，1）代表2x^1
#include <iostream>
using namespace std;
const int MAX = 25;
//结点类
class Term
{
public:
double m_coef; //系数
double m_expn; //指数
Term * m_next; //指向下一个结点的指针
//构造函数
Term( double f , double e )
{ this->m_coef = f;
this->m_expn = e ;
this->m_next = NULL;
}

Term()
{
m_coef = m_expn = 0.0;
m_next = NULL;
}
};
//多项式类
class Polynomial
{
private:

Term * m_tail; //尾指针
int m_len; //多项式的长度

public:
Term * m_head; //头指针
//构造函数
Polynomial();
Polynomial( double value[], int len );
void Push_back( double, double); //尾插法插入新结点
void Get(double arr[],int len1); //重新设置多项式
void SelectSort( Polynomial & ); //合并同类项
Polynomial &operator=( const Polynomial & ); //实现多项式的赋值
Polynomial &operator+( const Polynomial & ); //实现两个多项式的加法
Polynomial &operator-( const Polynomial & ); //实现两个多项式的减法
Polynomial &operator*( const Polynomial & ); //实现两个多项式的乘法
friend ostream& operator <<( ostream &, const Polynomial &); //实现多项式的输出
~Polynomial(){} //析构函数
};
//构造函数
Polynomial::Polynomial()
{
m_head = new Term();
m_tail = m_head;
m_len = 0;
}

Polynomial::Polynomial( double value[], int len)
{
m_head = new Term();
m_tail = m_head; m_len = 0;
for( int i = 0; i < len; i++ )
Push_back( value[i], value[i + len]);
}
//尾插法插入新结点
void Polynomial::Push_back( double co, double ex )
{
Term *pNode = new Term( co, ex );
m_tail->m_next = pNode;
m_tail = pNode;
m_len++;
}
//重新设置多项式的系数和指数，并存储到数组中
double arry[MAX*2];
void set_arry(int len)
{
int i=1;
cout << "输入" <<len<< "个系数 "<<len<< "个指数，没有的用0表示. "<<endl;
while( i <= len)
{
cout << "#"<< i << ":(系数 指数)" << endl;
cin >>arry[i];
cin >>arry[i + len];
i++;
}
for(i=1;i<= len;i++)
{
cout<<i<< " :("<<arry[i]<<" "<<arry[i+len]<<")" << endl;

}

}
//重新设置多项式
void Polynomial::Get(double arr[],int len1)
{
int i;
Term* pNode=m_head;
Term* pt;
/*当重新设置的多项式长度len1不大于原长度m_len时，
修改前len1的结点，并使尾指针指向最后一个被修改的结点，
多项式的长度等于len1*/
if(len1<=m_len)
{
for(i=0;i<=len1;i++)
{
pNode->m_coef=arr[i];
pNode->m_expn=arr[i+len1];
pt=pNode;
pNode=pNode->m_next;
}
m_tail=pt;
m_tail->m_next=NULL;
m_len=len1;
}
/*当重新设置的多项式长度len1大于原长度m_len时，
修改原多项式的所有结点，
再利用尾插法插入剩余（len1—m_len）个结点，
多项式的长度等于len1 */
else
{
for(i=0;i<=m_len;i++)
{
pNode->m_coef=arr[i];
pNode->m_expn=arr[i+len1];
pNode=pNode->m_next;
}
while(i<=len1)
{
Push_back(arr[i],arr[i+len1]);
i++;
}
m_tail=pNode;
m_len=len1;
}
}
//实现多项式的赋值，以原多项式所有结点的系数和指数建立新的结点，并插入到新的多项式中
Polynomial& Polynomial::operator=( const Polynomial & poly )
{
for(Term *pNode =poly.m_head->m_next; pNode; pNode = pNode->m_next)
{
Push_back(pNode->m_coef, pNode->m_expn);
if (pNode == poly.m_tail)
break;
}
return *this;
}
/*实现两个多项式的加法，并将结果放入第一个多项式；
（1）当第一个多项式的指数小于第二个多项式的指数时第一个多项式的指针指向下一个结点
（2）当第一个多项式的指数等于第二个多项式的指数时系数进行相加，
如果结果等于0，删除该结点，然后指针指向下一个结点
（3）当第一个多项式的指数大于第二个多项式的指数时，
将第二个多项式的指针指向的结点插入到第一个多项式当中*/
Polynomial & Polynomial::operator+( const Polynomial & poly )
{
Term *temp;
Term *pa = m_head->m_next;
Term *pre_pa = m_head;
Term *pb = poly.m_head->m_next;
while( pa != NULL && pb != NULL )
{
if( pa->m_expn < pb->m_expn )
{
pre_pa = pa;
pa = pa->m_next;
}
else
{
if( pa->m_expn == pb->m_expn )
{
pa->m_coef += pb->m_coef;
pb = pb->m_next;
if( pa->m_coef == 0 )
{
pre_pa->m_next = pa->m_next;
delete pa;
pa = pre_pa->m_next;
}
}

else
{
temp = pb->m_next;
pb->m_next = pa;
pre_pa->m_next = pb;
pre_pa = pre_pa->m_next;
pb = temp;
}

}
}
if(pb!=NULL)
{
m_tail->m_next=pb;
}

SelectSort( *this );
return *this;
}
//实现两个多项式的减法，将第二个多项式的系数置反，再调用加法运算
Polynomial & Polynomial::operator-( const Polynomial & poly )
{
Term * temp = NULL;
for( temp = poly.m_head->m_next; temp; temp = temp->m_next)
temp->m_coef = -temp->m_coef;
this->operator+( poly );
SelectSort( *this );
return *this;
}
/*实现两个多项式的乘法，将第一个多项式的每一项去乘第二个多项式的各项
并将结果以新的结点用尾插法插入到第一个多项式，然后再删除原第一个多项式的结点
然后合并同类项*/
Polynomial & Polynomial::operator*( const Polynomial & poly )
{
Term * pa, *pb;
int i, k=m_len;
for( pa = m_head->m_next, i = 0; pa && i < k; pa = pa->m_next,i++ )
for( pb = poly.m_head->m_next; pb; pb = pb->m_next )
{
Term * pc = new Term();
pc->m_coef = pa->m_coef * pb->m_coef;
pc->m_expn = pa->m_expn + pb->m_expn;
this->Push_back( pc->m_coef, pc->m_expn );
}
for( pa = m_head, i = 0; pa &&i<k; i++ )
{
pb = pa->m_next;
delete pa;
pa = pb;
m_head = pa;
}
SelectSort( *this );
return *this;
}
/*合并同类项函数，依次比较前一个结点与后面的所有结点，
指数相同时，系数相加，并将结果放入前面的结点，
后一个结点系数置0*/
void Polynomial::SelectSort( Polynomial & poly )
{
Term* pa = NULL;
Term* pb = NULL;
for( pa = poly.m_head->m_next; pa; pa = pa->m_next )
for( pb = pa->m_next; pb; pb = pb->m_next )
{
if( pa->m_expn == pb->m_expn )
{
pa->m_coef += pb->m_coef;
pb->m_coef = 0;
}
}
}
/*实现多项式的输出，依次输出系数不为0的结点*/
ostream & operator<<(ostream& os, Polynomial& poly )
{
os << endl;
int i = 0;
for( Term *temp = poly.m_head->m_next; temp; temp = temp->m_next )
{
if( temp->m_coef!= 0 )
{
os << " ( " << temp->m_coef << " , " << temp->m_expn << " ) ";
i++;
if( i % 6 == 0 )
os << endl;
}
}
os << endl;
return os;
}
//主函数进行调试
int main(void)
{

cout << "为方便调试，直接给出了两个一元多项式。" << endl;
double arr1[10] = { 2, 4, 6, 8, 10 , 1, 3, 5, 4, 9 };
double arr2[10] = { 1, 1, 2, 3, 4 , 1, 2, 3, 6, 7 };

Polynomial poly1(arr1, 5);
Polynomial poly2(arr2, 5);
Polynomial poly3, poly4,poly5,poly6,poly7,poly8, poly9,poly10,poly11,poly12,poly13,poly14,poly15 ;

cout<<"poly1 :"<<poly1;
cout<<"poly2 :"<<poly2;

poly3 = poly1; poly4 = poly2;
poly5 = poly1; poly6 = poly2;
poly7 = poly1; poly8 = poly2;
poly9 = poly1;

cout << "两个多项式之和（测试+）: " << poly3 + poly4 << endl;
cout << "两个多项式之差（测试-）: " << poly5 - poly6<< endl;
cout << "两个多项式之积（测试*）: " << poly7 * poly8 << endl;
cout << "第一个多项式（测试=）: " << poly9<< endl;
return 0;
}

Answer 3

简单，你看我的：

#include "stdio.h"
#define MAX 255
void MatrixMul(a,b,m,n,k,c) /*实矩阵相乘*/
int m,n,k; /*m:矩阵A的行数, n:矩阵B的行数, k:矩阵B的列数*/
double a[],b[],c[]; /*a为A矩阵, b为B矩阵, c为结果，即c = AB */
{
int i,j,l,u;
/*逐行逐列计算乘积*/
for (i=0; i<=m-1; i++)
for (j=0; j<=k-1; j++)
{
u=i*k+j; c[u]=0.0;
for (l=0; l<=n-1; l++)
c[u]=c[u]+a[i*n+l]*b[l*k+j];
}
return;
}

main()
{
int i,j,m,n,k;
double A[MAX];
double B[MAX];
double C[MAX];
for(i=0;i<MAX;i++)
C[i]=1.0;
clrscr();
puts("This is a real-matrix-multiplication program.\n");
puts("It calculate the two matrixes C(m*k)=A(m*n)B(n*k).\n");
printf(" >> Please input the number of rows in A, m= ");
scanf("%d",&m);
printf(" >> Please input the number of cols in A, n= ");
scanf("%d",&n);
printf(" >> Please input the number of cols in B, k= ");
scanf("%d",&k);
printf(" >> Please input the %d elements in A one by one:\n",m*n);
for(i=0;i<m*n;i++)
scanf("%lf",&A[i]);
printf(" >> Please input the %d elements in B one by one:\n",n*k);
for(i=0;i<n*k;i++)
scanf("%lf",&B[i]);

MatrixMul(A,B,m,n,k,C); /*计算C的结果*/
/*格式化输出结果*/
printf("\n >> The result of C(%d*%d)=A(%d*%d)B(%d*%d) is:\n",m,k,m,n,n,k);
for (i=0; i<m; i++)
{
for (j=0; j<k; j++)
printf("%10.5f ",C[i*k+j]);
printf("\n");
}
printf("\n Press any key to quit...\n");
getch();
return 0;
}
本回答被提问者采纳

Answer 4

#include <stdio.h>
void pm(double p[],int m,double q[],int n,double s[],int k)
{ //多项式p(x),最高m-1次；多项式q(x)，最高n-1次；
//结果s(x),最高k次,k=m+n-1
int i,j;
for (i=0; i<=k-1; i++)
s[i]=0.0;
for (i=0; i<=m-1; i++)
for (j=0; j<=n-1; j++)
s[i+j]=s[i+j]+p[i]*q[j];
}
int main()
{
//case
int i;
double p[6]={4.0,-6.0,5.0,2.0,-1.0,3.0};
double q[4]={2.0,3.0,-6.0,2.0};
double s[9];
pm(p,6,q,4,s,9);
for (i=0; i<9; i++)
printf("s(%d)=%f\n",i,s[i]);
printf("\n");
return 0;
}

Answer 5

AB*CD=AC*10^2+(AD+BC)*10+BD//四次乘法
=AC*10^2+[(A+B)*(C+D)-(AC+BD)]*10+BD//三次乘法

aX^3+bX^2+cX+d//8次乘法
=X(aX^2+bX+c)+d//5次乘法
=X(X(aX^1+b)+c)+d//3次乘法