C课程设计矩阵的加减乘混合运算.docx

C课程设计矩阵的加减乘混合运算.docx

《C课程设计矩阵的加减乘混合运算.docx》由会员分享，可在线阅读，更多相关《C课程设计矩阵的加减乘混合运算.docx（26页珍藏版）》请在冰豆网上搜索。

C课程设计矩阵的加减乘混合运算

矩阵混合运算

指导教师：

浙江理工大学

班级：

学号：

姓名：

矩阵混合运算

一、程序要求

二、输入输出范例

三、程序结构分析及关键函数说明

四、程序代码与说明

五、运行结果与分析

六、设计日志及心得体会

一、

程序要求及范例

·定义矩阵（维数小于5×5）的加减法和乘法

·计算输入的若干矩阵的加减法运算和乘法混合运算

·矩阵数目不定，混合运算顺序不定，矩阵数值不定，均有键盘输入控制

·若输入有错，可以随时更改任一矩阵数值

·当输入矩阵不能满足矩阵运算时，提示矩阵维数错误

二、输入输出范例

·输入：

-首先输入每个矩阵的数值，输入矩阵格式如[111;222]

-输入几个矩阵的混合运算

·输出：

-输出计算结果

·输入范例：

A=[111;222]

B=[10;01;11]

C=[10;01]

D=C+A*B或者D=A*B+C

·输出

-D=

32

45

三、程序结构分析及关键函数说明

1.加运算函数

在进行矩阵相加前要判断两矩阵是否能够相加，如果能就按照矩阵的相加方式进行运算，若不能则提示错误并返回，具体的程序段如下：

intaddMatrix（Matrix*c,Matrix*a,Matrix*b）

{

inti,j;

if（a->rows!

=b->rows||a->cols!

=b->cols）//errortoadd

{

printf（"矩阵维数输入错误！

"）；

return0;

}

else

{

c->rows=a->rows;

c->cols=a->cols;

for（i=0;irows;i++）

{

for（j=0;jcols;j++）

{

c->data[i][j]=a->data[i][j]+b->data[i][j];

}

}

return1;

}

}

2.减运算函数

在进行矩阵相减前要判断两矩阵是否能够相减，如果能就按照矩阵的相减方式进行运算，若不能则提示错误并返回，具体的程序段如下：

intsubtractMatrix（Matrix*c,Matrix*a,Matrix*b）

{

inti,j;

if（a->rows!

=b->rows||a->cols!

=b->cols）//error

{

printf（"矩阵维数输入错误！

"）;

return0;

}

else

{

c->rows=a->rows;

c->cols=a->cols;

for（i=0;irows;i++）

{

for（j=0;jcols;j++）

{

c->data[i][j]=a->data[i][j]-b->data[i][j];

}

}

return1;

}

}

3.乘运算函数

该程序设计的核心问题是矩阵的乘法运算的逻辑性的编写，在进行矩阵相乘前要判断两矩阵是否能够相乘，即判断内积是否相等，如果能就按照矩阵的相乘方式进行运算，若不能则提示错误并返回，具体的程序段如下：

intmultiplyMatrix（Matrix*c,Matrix*a,Matrix*b）

{

inti,j,k;

if（a->cols!

=b->rows）

{

printf（"矩阵维数输入错误！

"）;

return0;

}

else

{

c->rows=a->rows;

c->cols=b->cols;

for（i=0;irows;i++）

{

for（j=0;jcols;j++）

{

c->data[i][j]=0;

for（k=0;kcols;k++）

{

c->data[i][j]+=a->data[i][k]*b->data[k][j];

}

}

}

return1;

}

}

四、程序代码与说明

#include

#include

#include

#include

#defineMAX_DIM6

#defineMAX_CHAR128

typedefstruct//结构体定义矩阵

{

floatdata[MAX_DIM][MAX_DIM];//二维数组表示矩阵

introws;//行

intcols;//列

}Matrix;

typedefstruct_ListNode//定义一个头结点

{

charname[MAX_CHAR];

Matrix*mat;

struct_ListNode*next;//指向下一个结点

}ListNode;

typedefstruct

{

ListNode*head;//定义一个指向头结点的指针

}MList;

enumTYPE{OP,MAT};//枚举类型

typedefstruct_Token//定义Token标识符判断表达式

{

union//联合体取值为op和mat中结构最大的值

{

charop;

Matrix*mat;

};

enumTYPEtype;//联合体的类型

}Token;

typedefstruct_Stack//定义栈

{

Token**arr;//用数组存储标识符

intn;//数组里标识符的个数

intcap;//数组的大小

}Stack;

Stack*initStack（intcap）;//初始化，定义一个空栈

voidfreeStack（Stack*pStack）;//释放栈的空间

voidreszieStack（Stack*pStack,intnewCap）;//重定义栈的大小

voidpush（Stack*pStack,Token*pToken）;//入栈操作

Token*pop（Stack*pStack）;//出栈

Token*top（Stack*pStack）;//栈顶

intgetIndex（charch）;//不同标识符对应不同的操作

charpriorMap[9][9]=

{

{'>','>','<','<','<','<','<','>','>'},

{'>','>','<','<','<','<','<','>','>'},

{'>','>','>','>','<','<','<','>','>'},

{'>','>','>','>','<','<','<','>','>'},

{'>','>','>','>','>','>','<','>','>'},

{'>','>','>','>','>','>','<','>','>'},

{'<','<','<','<','<','<','<','=','$'},

{'>','>','>','>','>','>','&','>','>'},

{'<','<','<','<','<','<','<','&','='}

};

Matrix*newMatrix（introws,intcols）;//函数原型，创建新矩阵

voidfreeMatrix（Matrix*mat）;//销毁矩阵，释放内存

intaddMatrix（Matrix*c,Matrix*a,Matrix*b）;//矩阵的加法

intsubtractMatrix（Matrix*c,Matrix*a,Matrix*b）;//矩阵的减法

intmultiplyMatrix（Matrix*c,Matrix*a,Matrix*b）;//矩阵的乘法

voidprintMatrix（Matrix*mat）;//输出结果

ListNode*newNode（charname[],Matrix*mat）;

MList*newMList（）;

voidfreeNode（ListNode*node）;

voidfreeMList（MList*ml）;

voidaddNode（MList*ml,ListNode*node）;

ListNode*parseMat（charline[]）;

voidprintLNode（ListNode*node）;

Matrix*findByName（MList*ml,charname[]）;

intmain（）

{

printf（"矩阵的混合运算\n"）;

printf（"矩阵范例A=[111;222]\n"）;

printf（"请按范例格式输入\n"）;

charline[MAX_CHAR];

charname[MAX_CHAR];

char*pch;

MList*ml=newMList（）;

Matrix*newMat=NULL;

while

（1）

{

fgets（line,MAX_CHAR,stdin）;//输入一串字符

if（strlen（line）==1&&line[0]=='\n'）

{

continue;

}

pch=strchr（line,'['）;

if（pch!

=NULL）

{

ListNode*node=parseMat（line）;

addNode（ml,node）;

}

else

{

pch=strchr（line,'='）;

*pch='\0';

char*expr=pch+1;

Stack*pStackVals=initStack（16）;

Stack*pStackOps=initStack（16）;

Token*pToken=NULL,*pTokenA=NULL,*pTokenB=NULL;

pToken=（Token*）malloc（sizeof（Token））;

pToken->op='#';

pToken->type=OP;

push（pStackOps,pToken）;

intlen=strlen（expr）;

expr[len++]='#';

intb=0,e=0,cnt;

charch;

while（b!

=len）

{

ch=expr[b];

if（isspace（ch））//判断是否为空格

{

b++;

}

elseif（isalpha（ch））//矩阵

{

cnt=0;

e=b;

while（isalpha（expr[e]））

{

name[cnt++]=expr[e++];

}

name[cnt]='\0';

b=e;

Matrix*mat=findByName（ml,name）;

pToken=（Token*）malloc（sizeof（Token））;

pToken->type=MAT;

pToken->mat=mat;

push（pStackVals,pToken）;

}

else//操作符

{

while

（1）

{

charcmp=priorMap[getIndex（top（pStackOps）->op）][getIndex（ch）];

if（cmp=='<'）

{

pToken=（Token*）malloc（sizeof（Token））;

pToken->type=OP;

pToken->op=ch;

push（pStackOps,pToken）;

break;

}

elseif（cmp=='='）

{

free（pop（pStackOps））;

break;

}

elseif（cmp=='>'）

{

pToken=pop（pStackOps）;

switch（pToken->op）

{

case'+':

pTokenB=pop（pStackVals）;

pTokenA=pop（pStackVals）;

newMat=newMatrix（0,0）;

addMatrix（newMat,pTokenA->mat,pTokenB->mat）;

free（pTokenA）;

free（pTokenB）;

pToken=（Token*）malloc（sizeof（Token））;

pToken->type=MAT;

pToken->mat=newMat;

push（pStackVals,pToken）;

break;

case'-':

pTokenB=pop（pStackVals）;

pTokenA=pop（pStackVals）;

newMat=newMatrix（0,0）;

subtractMatrix（newMat,pTokenA->mat,pTokenB->mat）;

free（pTokenA）;

free（pTokenB）;

pToken=（Token*）malloc（sizeof（Token））;

pToken->type=MAT;

pToken->mat=newMat;

push（pStackVals,pToken）;

break;

case'*':

pTokenB=pop（pStackVals）;

pTokenA=pop（pStackVals）;

newMat=newMatrix（0,0）;

multiplyMatrix（newMat,pTokenA->mat,pTokenB->mat）;

free（pTokenA）;

free（pTokenB）;

pToken=（Token*）malloc（sizeof（Token））;

pToken->type=MAT;

pToken->mat=newMat;

push（pStackVals,pToken）;

break;

}

}

}

b++;

}

}

newMat=top（pStackVals）->mat;

freeStack（pStackVals）;

freeStack（pStackOps）;

break;

}

}

ListNode*resNode=newNode（line,newMat）;

printLNode（resNode）;

freeMList（ml）;

return0;

}

Matrix*newMatrix（introws,intcols）

{

Matrix*mat=（Matrix*）malloc（sizeof（Matrix））;

mat->rows=rows;

mat->cols=cols;

returnmat;

}

voidfreeMatrix（Matrix*mat）

{

free（mat）;

mat=NULL;

}

intaddMatrix（Matrix*c,Matrix*a,Matrix*b）

{

inti,j;

if（a->rows!

=b->rows||a->cols!

=b->cols）//errortoadd

{

printf（"矩阵维数输入错误！

"）;

return0;

}

else

{

c->rows=a->rows;

c->cols=a->cols;

for（i=0;irows;i++）

{

for（j=0;jcols;j++）

{

c->data[i][j]=a->data[i][j]+b->data[i][j];

}

}

return1;

}

}

intsubtractMatrix（Matrix*c,Matrix*a,Matrix*b）

{

inti,j;

if（a->rows!

=b->rows||a->cols!

=b->cols）//errortoadd

{

printf（"矩阵维数输入错误！

"）;

return0;

}

else

{

c->rows=a->rows;

c->cols=a->cols;

for（i=0;irows;i++）

{

for（j=0;jcols;j++）

{

c->data[i][j]=a->data[i][j]-b->data[i][j];

}

}

return1;

}

}

intmultiplyMatrix（Matrix*c,Matrix*a,Matrix*b）

{

inti,j,k;

if（a->cols!

=b->rows）

{

return0;

}

else

{

c->rows=a->rows;

c->cols=b->cols;

for（i=0;irows;i++）

{

for（j=0;jcols;j++）

{

c->data[i][j]=0;

for（k=0;kcols;k++）

{

c->data[i][j]+=a->data[i][k]*b->data[k][j];

}

}

}

return1;

}

}

voidprintMatrix（Matrix*mat）

{

inti,j;

for（i=0;irows;i++）

{

for（j=0;jcols;j++）

{

printf（"\t%.2f",mat->data[i][j]）;

}

printf（"\n"）;

}

}

voidprintLNode（ListNode*node）

{

printf（"%s=\n",node->name）;

printMatrix（node->mat）;

}

ListNode*newNode（charname[],Matrix*mat）

{

ListNode*node=（ListNode*）malloc（sizeof（ListNode））;

strcpy（node->name,name）;

node->mat=mat;

node->next=NULL;

returnnode;

}

MList*newMList（）

{

MList*ml=（MList*）malloc（sizeof（MList））;

ml->head=NULL;

returnml;

}

voidfreeNode（ListNode*node）

{

if（node==NULL）

{

return;

}

freeMatrix（node->mat）;

free（node）;

}

voidfreeMList（MList*ml）

{

if（ml==NULL）

{

return;

}

ListNode*currNode,*temp;

currNode=ml->head;

while（currNode!

=NULL）

{

temp=currNode;

freeNode（temp）;

currNode=currNode->next;

}

free（ml）;

}

voidaddNode（MList*ml,ListNode*node）

{

node->next=ml->head;

ml->head=node;

}

ListNode*parseMat（charline[]）

{

chartmp[MAX_CHAR];

Matrix*mat=newMatrix（0,0）;

char*pch,*pch1,*pstop;

pch=strchr（line,'='）;

*pch='\0';

ListNode*node=newNode（line,mat）;

char*data=pch+2;

pstop=strchr（data,']'）;

*pstop='\0';

pch=strtok（data,";"）;

while（pch!

=NULL）

{

strcpy（tmp,pch）;

pch1=strtok（tmp,""）;

mat->cols=0;

while（pch1!

=NULL）

{

mat->data[mat->rows][mat->cols++]=atof（pch1）;

pch1=strtok（NULL,""）;

}

mat->rows++;

if（pch+strlen（pch）==pstop）

{

break;

}

pch=strtok（pch+strlen（pch）+1,";"）;

}

returnnode;

}

Matrix*findByName（MList*ml,charname[]）

{

ListNode*currNode=ml->head;

while（currNode!

=NULL）

{

if（strcmp（name,currNode->name）==0）

{

returncurrNode->mat;

}

currNode=currNode->next;

}

returnNULL;

}

Stack*initStack（intcap）

{

inti;

Stack*pSta