稀疏矩阵实验报告

稀 疏 矩 阵

实

验

报

告

班级：信管1102

姓名：喻雅刚

学号：11300530210

日期：1月3号

期《稀疏矩阵》实验报告

◎实验题目: 有输入界面（图形或文字界面都可），能区分加法、减法、乘法和转置；能处理任意输入的典型数据和进行出错数据处理（例如乘法，当第一个矩阵的列数不等于第二个矩阵的行数时）；必须采用三元组作存储结构，不能采用数组等形式；输出要求用矩阵的形式输出（即习题集136页的形式），当第一个矩阵的行数不等于第二个矩阵的行数时，注意如第三个乘法的形式输出

◎实验目的：设计算法，实现矩阵的加减乘以及转置。

◎实验内容：有输入界面（图形或文字界面都可），能区分加法、减法、乘法和转置；能处理任意输入的典型数据和进行出错数据处理（例如乘法，当第一个矩阵的列数不等于第二个矩阵的行数时）；必须采用三元组作存储结构，不能采用数组等形式；输出要求用矩阵的形式输出（即习题集136页的形式），当第一个矩阵的行数不等于第二个矩阵的行数时，注意如第三个乘法的形式输出

一、需求分析

说明程序设计的任务，强调的是程序要做什么，明确规定：

1、输入的形式和输入值的范围；

2、输出的形式；

3、程序所能达到的功能；

4、测试数据：包括正确的输入及其输出结果和含有错误的输入及其输出结果。

二 概要设计

说明本程序中用到的所有抽象数据类型的定义、主程序的流程以及各程序模块之间的层次（调用）关系。

三 详细设计

实现概要设计中定义的所有数据类型，对每个操作只需要写出伪码算法；对主程序和其他模块也都需要写出伪码算法；画出函数的调用关系。?

四 使用说明、测试分析及结果

1、说明如何使用你编写的程序；

2、测试结果与分析；

3、调试过程中遇到的问题是如何解决提以及对设计与实现的回顾讨论和分析；

4、运行界面。

五、实验总结

1、算法的时空分析和改进设想等等，见示例。

报告：

(一) 需求分析

1．本演示程序中，矩阵的行列人为规定，由个人输入需要计算的矩阵，首先选择自己需要计算方式，在输入所需要计算的矩阵，程序将根据选择进行计算，最后输出结果。

2．演示程序以用户和计算机的对话方式执行，即在计算机终端上显示“提示信息”之后，由用户在键盘上输入相应数据（所需计算矩阵的行列数及矩阵内个元素），程序将自动将稀疏矩阵保存在三元标中。

3．程序执行的命令包括：

（1）构建三元列表；（2）输入所需计算矩阵的行列数；（3）输入矩阵内的全部元素（4）根据选择进行矩阵计算（5）输出矩阵

4．测试数据

（1）a.mu=3 a.nu=3， 1 0 1

2 0 0

0 2 1

b.mu b.nu 0 1 2

1 1 1

1 0 2

加法输出：1 1 3 减法输出： 1 -1 -1 乘法输出： 1 1 4

3 1 1 1 -1 -1 0 0 0

1 2 3 -1 2 -1 3 0 2

(二) 概要设计

为了实现上述操作，应以单向循环链表为存储结构。

1．input(&b)

基本操作： 以此输入稀疏矩阵内每个元素

? 操作结果：建立三元列表b，并想稀疏矩阵内输入数据

addmtirx( &a, &b, &c);

初始条件：存在两个不为空稀疏矩阵和一个空的三元列表

操作结果 ：将两个稀疏矩阵相加，并将得数存储在c中

transposesmatrix(&a,&b);

初始条件：存在一个不为空稀疏矩阵和一个空的三元列表

操作结果 ：将含有数据的稀疏矩阵转置，并将得数存储在b中

multmatrix(&a,&b,&c);

初始条件：存在两个不为空稀疏矩阵和一个空的三元列表

操作结果 ：将两个稀疏矩阵相乘，并将得数存储在c中

submtirx(&a,&b,&c)

初始条件：存在两个不为空稀疏矩阵和一个空的三元列表

操作结果 ：将两个稀疏矩阵相加减，并将得数存储在c中

Out put ( )

? 初始条件：存放稀疏矩阵三元列表存在

? 操作结果：输出计算后的稀疏矩阵

2． 本程序包含三个模块：

（1）主程序模块；

（2）输入需要计算的稀疏矩阵

（3）选择计算方法，并计算

（4）输出计算后的矩阵

（5）模块调用图：

主程序模块

输入需要计算的稀疏矩阵

选择计算方法，并计算

输出计算后的矩阵

(三) 详细设计

1．元素类型，列表类型和指针类型：

# include<stdio.h>

#include <stdlib.h>

#define maxsize 100

typedef int datatype;

typedef struct//定义三元组

{

int i,j;

datatype x;

}matrix;

typedef struct//定义三元组表

{

matrix data[maxsize];

int mu,nu,tu;//矩阵行,列,非零元个数

}tripulematrix;

?2．每个模块的分析：

（1）主程序模块：

void main()

{

printf("----------------矩 阵 计 算---------------\n");

printf("请选择你需要的计算方式\n");

printf("-----------------1.稀疏矩阵的转置---------------\n");

printf("-----------------2.稀疏矩阵的加法---------------\n");

printf("-----------------3.稀疏矩阵的减法---------------\n");

printf("-----------------4.稀疏矩阵的乘法---------------\n");

char x;

scanf("%c",&x);

tripulematrix a,b,c;

switch(x)

{

case '1':

//tripulematrix a,b;

printf("请输入矩阵的行数与列数\n");

scanf("%d%d",&a.mu,&a.nu);

b.mu=a.mu;

b.nu=a.nu;

printf("请输入一个矩阵，例如：\n");

printf("1 2 3\n2 3 4\n4 5 6\n");

printf("请输入\n");

input(&a);

transposesmatrix(&a,&b);

output(&b);

break;

case '2':

// tripulematrix a,b,c;

printf("请输入矩阵的行数与列数\n");

scanf("%d%d",&a.mu,&a.nu);

b.mu=a.mu;

b.nu=a.nu;

printf("请输入两个矩阵，例如：\n");

printf("1 2 3\n2 3 4\n4 5 6\n");

printf("请输入\n");

printf("请输入第一个矩阵\n");

input(&a);

printf("请输入第二个矩阵\n");

input(&b);

addmtirx( &a, &b, &c);

output(&c);

break;

case '3':

//tripulematrix a,b,c;;

printf("请输入矩阵的行数与列数\n");

scanf("%d%d",&a.mu,&a.nu);

b.mu=a.mu;

b.nu=a.nu;

printf("请输入两个矩阵，例如：\n");

printf("1 2 3\n2 3 4\n4 5 6\n");

printf("请输入\n");

printf("请输入第一个矩阵\n");

input(&a);

printf("请输入第二个矩阵\n");

input(&b);

submtirx(&a,&b,&c);

break;

case '4':

//tripulematrix a,b,c;;

printf("请输入矩阵的行数与列数\n");

scanf("%d%d",&a.mu,&a.nu);

b.mu=a.mu;

b.nu=a.nu;

printf("请输入两个矩阵，例如：\n");

printf("1 2 3\n2 3 4\n4 5 6\n");

printf("请输入第一个矩阵\n");

input(&a);

printf("请输入第二个矩阵\n");

input(&b);

multmatrix(&a,&b,&c);

break;

case '5':

exit(0);

break;

system("pause");

}

（2）输入数据

void input (tripulematrix *a)

{

int i,j ,k=0;

datatype x;

for (i=0;i<a->mu;i++)

{

for (j=0;j<a->nu;j++)

{

scanf("%d",&x);

if (x)//如果是非零元

{

a->data[k].i=i;

a->data[k].j=j;

a->data[k].x=x;

k++;

}

}

}

a->tu=k;

}//input

（3）加法

datatype addmtirx(tripulematrix *a,tripulematrix *b,tripulematrix *c)

{

int k=0,l=0;

c->mu=a->mu;

c->nu=a->nu;

c->tu=0;

while (k<a->tu&&l<b->tu)

{

if ((a->data[k].i==b->data[l].i)&&(a->data[k].j==b->data[l].j))

{

int temp=a->data[k].x+b->data[l].x;

if (temp!= 0)

{

c->data[c->tu].x=a->data[k].x+b->data[l].x;

c->data[c->tu].i=a->data[k].i;

c->data[c->tu].j=a->data[k].j;

c->tu++;

}

k++;l++;

}

else

if ((a->data[k].i==b->data[l].i)&&(a->data[k].j<b->data[l].j))

{

c->data[c->tu].x=a->data[k].x;

c->data[c->tu].i=a->data[k].i;

c->data[c->tu].j=a->data[k].j;

c->tu++;

k++;

}

else

{

if (((a->data[k].i==b->data[l].i)&&(a->data[k].j>b->data[l].j))||(a->data[k].i>b->data[l].i))

{

c->data[c->tu].i=b->data[l].i;

c->data[c->tu].j=b->data[l].j;

c->data[c->tu].x=b->data[l].x;

c->tu++;

l++;

}

}

}

while(k<a->tu)

{

c->data[c->tu].x=a->data[k].x;

c->data[c->tu].i=a->data[k].i;

c->data[c->tu].j=a->data[k].j;

c->tu++;

k++;

}

while(l<b->tu)

{

c->data[c->tu].i=b->data[l].i;

c->data[c->tu].j=b->data[l].j;

c->data[c->tu].x=b->data[l].x;

c->tu++;

l++;

}

return (1);

}

（4）减法

datatype submtirx(tripulematrix *a,tripulematrix *b,tripulematrix *c)//减法

{

int k=0,l=0;

c->mu=a->mu;

c->nu=a->nu;

c->tu=0;

while (k<a->tu&&l<b->tu)

{

if ((a->data[k].i==b->data[l].i)&&(a->data[k].j==b->data[l].j))

{

//int temp=a->data[k].x-b->data[l].x;

//if (temp!= 0)

//{

c->data[c->tu].x=a->data[k].x-b->data[l].x;

c->data[c->tu].i=a->data[k].i;

c->data[c->tu].j=a->data[k].j;

c->tu++;

//}

k++;l++;

}

else

if ((a->data[k].i==b->data[l].i)&&(a->data[k].j<b->data[l].j)||(a->data[k].i<b->data[l].i))

{

c->data[c->tu].x=a->data[k].x;

c->data[c->tu].i=a->data[k].i;

c->data[c->tu].j=a->data[k].j;

c->tu++;

k++;

}

else

{

if (((a->data[k].i==b->data[l].i)&&(a->data[k].j>b->data[l].j))||(a->data[k].i>b->data[l].i))

{

c->data[c->tu].i=b->data[l].i;

c->data[c->tu].j=b->data[l].j;

c->data[c->tu].x=-b->data[l].x;

c->tu++;

l++;

}

}

}

while(k<a->tu)

{

c->data[c->tu].x=a->data[k].x;

c->data[c->tu].i=a->data[k].i;

c->data[c->tu].j=a->data[k].j;

c->tu++;

k++;

}

while(l<b->tu)

{

c->data[c->tu].i=b->data[l].i;

c->data[c->tu].j=b->data[l].j;

c->data[c->tu].x=-b->data[l].x;

c->tu++;

l++;

}

return (1);

}

（5）转置

int transposemartix(tripulematrix *a,tripulematrix *b)

{

int col,p,q;

b->mu=a->nu;

b->nu=a->mu;

b->tu=a->tu;

if(b->tu)

{

q=0;

for(col=0;col<a->nu;col++)

{

for(p=0;p<a->tu;p++)

if(a->data[p].j==col)

{

b->data[p].i=a->data[q].j;

b->data[p].j=a->data[q].i;

b->data[p].x=a->data[q].x;

q++;

}

}

}

return (1);

}//稀疏矩阵的转置算法

(六)乘法int multmatrix(tripulematrix *a,tripulematrix *b, tripulematrix *c)

{

int rpos1[maxsize],rpos2[maxsize],num[maxsize],rpos3[maxsize];

int row1,row2,arow,tp,t,brow,ccol,p,q,k;

int ctemp[maxsize];

if (a->tu)

{

for (row1=0;row1<a->mu;row1++)

{

num[row1]=0;

}

for(row1=0;row1<a->tu;row1++)

{

++num[a->data[row1].i];

}

rpos1[0]=0;

for(row1=1;row1<a->mu;row1++)

{

rpos1[row1]=rpos1[row1-1]+num[row1-1];

}

}

if (b->tu)

{

for (row2=0;row2<b->tu;row2++)

{

num[row2]=0;

}

for(row2=0;row2<b->tu;row2++) ++num[b->data[row2].i];

rpos2[0]=0;

for(row2=1;row2<b->mu;row2++) rpos2[row2]=rpos2[row2-1]+num[row2-1];

}

c->mu=a->mu;c->nu=b->nu;c->tu=0;

if(a->tu*b->tu != 0)

{

for (arow=0;arow<a->mu;arow++)

{

for(k=0;k<maxsize;k++) ctemp[k]=0;

rpos3[arow]=c->tu+1;

if (arow<a->mu-1)

{

tp=rpos1[arow+1];

}

else

tp=a->tu;

for (p=rpos1[arow];p<tp;p++)

{

brow=a->data[p].j;//找到对应元在b中的行号

if (brow<b->nu-1)

{

t=rpos2[brow+1];

}

else t=b->tu;

for (q=rpos2[brow];q<t;q++)

{

ccol=b->data[q].j;//乘积元素在Q中的列号

ctemp[ccol] += (a->data[p].x)*(b->data[q].x);

}

}

for(ccol=0;ccol<c->nu;ccol++)

{

if (ctemp[ccol])

{

if (c->tu>maxsize)

{

return 0;

}

c->data[c->tu].i=arow;

c->data[c->tu].j=ccol;

c->data[c->tu].x=ctemp[ccol];

c->tu++;

}

}

}

}

return 1;

}

（4）函数调用关系图

main()

input(&a);

transposesmatrix(&a,&b);

submtirx(&a,&b,&c);

addmtirx( &a, &b, &c);

multmatrix(&a,&b,&c);

output();

3．完整的程序：

// 稀疏矩阵.cpp : 定义控制台应用程序的入口点。

//

#include<stdio.h>

#define maxsize 100

typedef struct

{

int i,j; //该非零元的行和列

int v; //该非零元的值

}

triple;typedef struct

{

triple data[maxsize]; //非零元三元组表，data[0]未用

int rpos[maxsize];

int m,n,t; //矩阵的行数，列数和非零元个数

}

tripletable;

void convert() //矩阵的转置

{ int k;

tripletable A,B;

printf("输入稀疏矩阵A的行数，列数和非零元个数：");

scanf("%d %d %d",&A.m,&A.n,&A.t);

for(k=1;k<=A.t;k++)

{

printf("输入第%d个非0元素的行数，列数和值:",k);

scanf("%d %d %d",&A.data[k].i,&A.data[k].j,&A.data[k].v);

}

B.m=A.m;B.n=A.n;B.t=A.t;

if(B.t)

{

int q=1,col; for(col=1;col<=A.n;++col)

for(int p=1;p<=A.t;++p)

if(A.data[p].j==col)

{

B.data[q].i=A.data[p].j;

B.data[q].j=A.data[p].i;

B.data[q].v=A.data[p].v;

++q;

}

}

int shuru[100][100]={0};

for(k=1;k<=B.t;k++)

{

shuru[B.data[k].j][B.data[k].i]=B.data[k].v;

}

printf("输入为：\n");

for(k=1;k<=B.m;k++)

{

for(int l=1;l<=B.n;l++)

printf("%d ",shuru[k][l]);

printf("\n");

}

int result[100][100]={0};

for(k=1;k<=B.t;k++)

{

result[B.data[k].i][B.data[k].j]=B.data[k].v;

}

printf("结果为：\n");

for(k=1;k<=B.n;k++)

{

for(int l=1;l<=B.m;l++)

printf("%d ",result[k][l]);

printf("\n");

}

}

void add() //矩阵的加法

{

int k; tripletable A,B;

printf("输入稀疏矩阵A的行数，列数和非零元个数：");

scanf("%d %d %d",&A.m,&A.n,&A.t);

for(k=1;k<=A.t;k++)

{

printf("输入第%d个非0元素的行数，列数和值:",k);

scanf("%d %d %d",&A.data[k].i,&A.data[k].j,&A.data[k].v);

}

printf("输入稀疏矩阵B的行数，列数和非零元个数：");

scanf("%d %d %d",&B.m,&B.n,&B.t);

for(k=1;k<=B.t;k++)

{

printf("输入第%d个非0元素的行数，列数和值:",k);

scanf("%d %d %d",&B.data[k].i,&B.data[k].j,&B.data[k].v);

}

if(A.m!=B.m||A.n!=B.n)

{

printf("输入错误：A与B的行数或列数不相同，请重新输入\n");

return;

}

int a[100][100]={0};

for(k=1;k<=A.t;k++)

{

a[A.data[k].i][A.data[k].j]=A.data[k].v;

}

printf("A输入为：\n");

for(k=1;k<=A.m;k++)

{

for(int l=1;l<=A.n;l++)

printf("%d ",a[k][l]);

printf("\n");

}

int b[100][100]={0};

for(k=1;k<=B.t;k++)

{

b[B.data[k].i][B.data[k].j]=B.data[k].v;

}

printf("B输入为：\n");

for(k=1;k<=B.m;k++)

{

for(int l=1;l<=B.n;l++)

printf("%d ",b[k][l]);

printf("\n");

}

int c[100][100]={0};

for(k=1;k<=A.m;k++)

{

for(int l=1;l<=A.n;l++)

{

c[k][l]=a[k][l]+b[k][l];

}

}

printf("加法结果C为：\n");

for(k=1;k<=A.m;k++)

{

for(int l=1;l<=A.n;l++)

printf("%d ",c[k][l]);

printf("\n");

}

}

void jian() //矩阵的减法

{

int k; tripletable A,B;

printf("输入稀疏矩阵A的行数，列数和非零元个数：");

scanf("%d %d %d",&A.m,&A.n,&A.t);

for(k=1;k<=A.t;k++)

{

printf("输入第%d个非0元素的行数，列数和值:",k);

scanf("%d %d %d",&A.data[k].i,&A.data[k].j,&A.data[k].v);

}

printf("输入稀疏矩阵B的行数，列数和非零元个数：");

scanf("%d %d %d",&B.m,&B.n,&B.t);

for(k=1;k<=B.t;k++)

{

printf("输入第%d个非0元素的行数，列数和值:",k);

scanf("%d %d %d",&B.data[k].i,&B.data[k].j,&B.data[k].v);

}

if(A.m!=B.m||A.n!=B.n)

{

printf("输入错误：A与B的行数或列数不相同，请重新输入\n");

return;

}

int a[100][100]={0};

for(k=1;k<=A.t;k++)

{

a[A.data[k].i][A.data[k].j]=A.data[k].v;

}

printf("A输入为：\n");

for(k=1;k<=B.m;k++)

{

for(int l=1;l<=A.n;l++)

printf("%d ",a[k][l]);

printf("\n");

}

int b[100][100]={0};

for(k=1;k<=B.t;k++)

{

b[B.data[k].i][B.data[k].j]=B.data[k].v;

}

printf("B输入为：\n");

for(k=1;k<=B.m;k++)

{

for(int l=1;l<=B.n;l++)

printf("%d ",b[k][l]);

printf("\n");

}

int c[100][100]={0};

for(k=1;k<=A.m;k++)

{

for(int l=1;l<=A.n;l++)

{

c[k][l]=a[k][l]-b[k][l];

}

}

printf("减法结果C为：\n");

for(k=1;k<=A.m;k++)

{

for(int l=1;l<=A.n;l++)

printf("%d ",c[k][l]);

printf("\n");

}

}

void multi() //矩阵的乘法

{

int k; tripletable A,B,C;

printf("输入稀疏矩阵A的行数，列数和非零元个数：");

scanf("%d %d %d",&A.m,&A.n,&A.t);

for(k=1;k<=A.t;k++)

{

printf("输入第%d个非0元素的行数，列数和值:",k);

scanf("%d %d %d",&A.data[k].i,&A.data[k].j,&A.data[k].v);

}

int row=1;

for(k=1;k<=A.t;k++)

{

while(row<=A.data[k].i)

{

A.rpos[row++]=k;

}

}

while(row<=A.m)A.rpos[row++]=A.t+1;

printf("输入稀疏矩阵B的行数，列数和非零元个数：");

scanf("%d %d %d",&B.m,&B.n,&B.t);

for(k=1;k<=B.t;k++)

{

printf("输入第%d个非0元素的行数，列数和值:",k);

scanf("%d %d %d",&B.data[k].i,&B.data[k].j,&B.data[k].v);

}

row=1;

for(k=1;k<=B.t;k++)

{

while(row<=B.data[k].i)

{

B.rpos[row++]=k;

}

}

while(row<=B.m)B.rpos[row++]=B.t+1;

if(A.n!=B.m)

{

printf("输入错误：A的列数不等于B的行数，请重新输入\n");

return;

}

C.m=A.m;C.n=B.n;C.t=0;

int arow,p,q,ccol,t,tp;

if(A.t*B.t!=0)

{

for(arow=1;arow<=A.m;++arow)

{

int ctemp[maxsize]={0};

C.rpos[arow]=C.t+1;

if(arow<A.m){tp=A.rpos[arow+1];

}

else{tp=A.t+1;

}

for(p=A.rpos[arow];p<tp;++p)

{

int brow=A.data[p].j;

if(brow<B.m){t=B.rpos[brow+1];

}

else{t=B.t+1;

}

for(q=B.rpos[brow];q<t;++q)

{

ccol=B.data[q].j;

ctemp[ccol]+=A.data[p].v*B.data[q].v;

}

}

for(ccol=1;ccol<=C.n;++ccol)

{

if(ctemp[ccol])

{

if(++C.t>maxsize)return;

C.data[C.t].i=arow;

C.data[C.t].j=ccol;

C.data[C.t].v=ctemp[ccol];

}

}

}

}

int a[100][100]={0};

for(k=1;k<=A.t;k++)

{

a[A.data[k].i][A.data[k].j]=A.data[k].v;

}

printf("A输入为：\n");

for(k=1;k<=A.m;k++)

{

for(int l=1;l<=A.n;l++)

printf("%d ",a[k][l]);

printf("\n");

}

int b[100][100]={0};

for(k=1;k<=B.t;k++)

{

b[B.data[k].i][B.data[k].j]=B.data[k].v;

}

printf("B输入为：\n");

for(k=1;k<=B.m;k++)

{

for(int l=1;l<=B.n;l++)

printf("%d ",b[k][l]);

printf("\n");

}

int c[100][100]={0};

for(k=1;k<=C.t;k++)

{

c[C.data[k].i][C.data[k].j]=C.data[k].v;

}

printf("乘法结果C为：\n");

for(k=1;k<=C.m;k++)

{

for(int l=1;l<=C.n;l++)

printf("%d ",c[k][l]);

printf("\n");

}

}

void main()

{

printf("============= 菜 单 ==============\n");

printf(" 1 矩阵转置\n");

printf(" 2 矩阵加法\n");

printf(" 3 矩阵减法\n");

printf(" 4 矩阵乘法\n");

printf("======================================\n\n");loop:

printf("请选择相应操作的序号:");

int y;

scanf("%d",&y);

switch(y)

{

case 1: convert();

printf("\n");

goto loop;

case 2: add();

printf("\n");

goto loop;

case 3: jian();

printf("\n");

goto loop;

case 4: multi();

printf("\n");

goto loop;

}

}

} (四) 程序使用说明及测试结果

1．程序使用说明

（1）本程序的运行环境为VC6.0。

（2）进入演示程序后即显示提示信息：

----------------矩 阵 计 算---------------

请选择你需要的计算方式

-----------------1.稀疏矩阵的转置---------------

-----------------2.稀疏矩阵的加法---------------

-----------------3.稀疏矩阵的减法---------------

-----------------4.稀疏矩阵的乘法---------------

1

请输入矩阵的行数与列数

3 3

请输入一个矩阵，例如：

1 2 3

1 1 1

1 1 1

得出： 1 1 1

2 1 1

3 1 1

请按任意键继续. . .

3．调试中的错误及解决办法。

(1) 转置出现问题

(2) 输出时无法利用数组第一个空间

(3) 三元表定义是无rpos(每行第一个非零元位置)

解决方式：逐步调试，以及问同学，自己更改算法，计算出rpos

4．运行界面

（五）、实验总结(实验心得)

你在编程过程中花时多少？

2天

多少时间在纸上设计？

1天

多少时间上机输入和调试？

1天

多少时间在思考问题？

2天

遇到了哪些难题？

对算法的思想领会的不深，程序无法输出，程序无限循环，程序崩溃等问题，还有由于疏忽导致的拼写错误

你是怎么克服的？

重新逐步调试，和同学交流。

你的收获有哪些？

平时要多和同学交流解决问题，在程序上不能有一点马虎大意，平时也应该多看一些有用的编程类的书

实验成绩：

指导教师签名：

批阅日期：