苏科版数学七年级下册10.3(教学设计)《解二元一次方程组》

计算器的设计
第一章需求分析
1.1 加减乘除的运算
设计一个简单的计算器，能够在有限位数内实现加、减、乘、除运算，并支持括号和小数。

1.2进制转换
通过该计算器可以实现二进制、十进制、八进制、十六进制之间的转换和运算。

这个程序首先要求选择一种数值转换的种类，例如我们可以选择二进制输入，十进制输出，这样就要求我们把输入的二进制转换成十进制。

由于按照我们要求的输入，输出，总共有6种情况。

所以我们不能一一写出来每个程序的执行过程，对于不同的情况我们只需要定义不同的输入函数和输出函数，根据不同的情况，调用不同的输入函数和输出函数，这样做是为了对于多进制的情况，这样能简化程序。

我定义了二进制输入，十进制输入，十六进制输入，二进制输出，十进制输出，十六进制输出，这样就能满足各种需要。

1.3一元多项式的运算
通过 C 语言实现多项式的的计算功能，输入多项式的项数、每项的系数和指数，将两个多项式进行加减进行加减运算。

该内容包括输入并建立多项式、多项式相加、多项式相减、多项式求值及输出多项式。

本项功能使用链式存储结构存储一元多项式，可以方便的计算简单的一元多项式的基本运算。

1.4实现形式
要求采用链表结构进行实现
第二章功能描述
2.1全局功能模块图
图1全局功能图
全局功能模块图说明：该计算器主要实现四则运算、进制的转换以及一元多项式的加减运算。

在四则运算中主要功能有整型数据的加减乘除运算，进制转换分为二进制转换为十进制、八进制转换为十进制、十六进制转换为十进制，一元多项式的计算分为加法运算和减法运算，以下是对计算器功能实现的具体说明。

2.2四则运算功能描述
计算器可以进行简单的加减乘除运算，可以判断用户的错误输入并且进行限制提示，比如：输入的左右括号不匹配，除数为0,输入非法字符时，都会有相应的提示，对用户比较友好。

在进行加减乘除的运算过程中，程序的运算部分建立了两个堆栈，分别用来存储操作符和操作数。

接收的用户输入可细分为四种，分别是数字，加减乘除操作符及左括号，右括号，等号。

根据个符号的优先级进行计算式的运算。

此程序调用的函数主要有<math.h> /* 数学函数的定义*/<conio.h> /* 屏幕操作函数*/<stdio.h> /*1/0 函数*/<stdlib.h> /* 库函数*/<stdarg.h> 〃<ctype.h> /* 字符操作函数*/。

基本使用：用控制鼠标图形移动，当
*变量长度参数表*/<graphics.h> /* 图形函数*/<string.h> /* 字符串函数* 移动
到相应得按钮时按回车键输入当前数字或执行对应的函数。

加法: 输入一个被加数数，按“ +”，输入被加数，按“ =”，输出结果。

乘法: 输入一个数，按“ * ”，输入另个数，按“ =”，输出结果。

除法: 输入一个被除数，按“ +”，输入另个除数，按“ =”，输出结果。

求余：输入一个数，按“ mod,按“=”，输出结果。

取整：输入一个数，按“ int ”，按“ =”，输出结果。

2.3 进制转换功能描述
输入一个八进制数，按“ 8->10”，按“ =”，输出十进制结果。

十六进制转十进制：输入一个十六进制数，按下“jz ” +“ 16- >10”按“=”, 输出十进制结果
2.4一元多项式运算功能描述
一元多项式的计算是常用的数学计算，在计算机计算中是非常普遍的，为了更加方便的进行此类运算，在此设计了一个简单的一元多项式计算器，用于对一元多项式进行创建，输出，以及一元多项式之间的相加，相减。

该程序简单，清晰，明了，用户易懂易用，能较好得实现一元多项式的计算功能[2]。

程序的基本功能：
(1)建立多项式
(2)输出多项式
(3)两个多项式相加，建立并输出和多项式
(4)两个多项式相减，建立并输出差多项式
(5)两个多项式相乘，建立并输出乘多项式
第三章功能的设计
3.1四则运算设计思路
系统在进行加减乘除的运算时，程序中主要运用堆栈这一数据逻辑结构。

并建立了两个堆栈，当遇到数字时直接压入操作数堆栈；当遇到加减乘除或左括号时进行优先级判断：如果传入的操作符优先级大于栈顶操作符的优先级则操作符入栈，如果传入的操作符优先级小于等于栈顶操作数的优先级则将栈顶操作符弹出，另外从操作数堆栈弹出两操作数进行运算，运算结果压入操作数堆栈；当遇到右括号时从两堆栈中弹出数据进行运算(每次结果压入操作数堆栈) ，直至遇到左括号
从堆栈中弹出为止；当遇到等号时从两堆栈中弹出数据进行运算，直至操作符堆栈为空。

switch(act) /* 根据运算符号计算*/
{
case 1:
result=num1+num2;break; /* 做加法*/
case 2:
result=num1-num2;break; /* 做减法*/
case 3:
result=num1*num2;break; /* 做乘法*/
case 4:
result=num1/num2;break; /* 做除法*/
3.2进制转换设计思路
在进行十六进制转化为十进制或八进制时，需要注意的是：先输入一个十六进制数据，再输入“ sft ”然后输入“ 16->10”或“ 16->8”，最后输入“ =”，输出转换后的结果。

3.2.1十六进制转换为十进制本段程序的作用是将十六进制转化为十进制，该程序是作为十六进制转化为其他进制的桥梁。

十六进制向十进制的转换分成两个大的步骤，一是从十六进制向二进制的转换，由于十六进制和二进制的特殊关系，它们之间的转换非常简单。

二是从二进制转换为十进制，相对而言，这种转换复杂一些。

所以该模块的核心是实现二进制数向十进制数的转换。

方法是将要转换的二进制数预先放到AX寄存器中，判断AX中数的符号，若为负数，则将负号送入输出缓冲区，并求AX的绝对值；若AX中的数为正数，则不做其他处理，此时AX中即为无符号二
进制数。

然后将无符号二进制数转换成十进制数，可采用将AX除以10 ,得到第
一个商和第一个余数，第一个余数就是所求十进制数的个位：将第一个商除以10，得到第二个商和余数，第二个余数就是所求十进制数的十位数，重复以上过程，一直循环到商为0时，得到的余数就是所求十进制数的最高位数。

这就是数制转换中常用的“除模留余倒排列”法则。

cd1=strlen(str7);
for(i=0,j=1;i<cd1;i++,j++)
{
if(str7[i]=='1')
num=num+1*pow(16,cd1-j);
else
if(str7[i]=='2')
num=num+2*pow(16,cd1-j);
else
if(str7[i]=='3')
num=num+3*pow(16,cd1-j);
else
if(str7[i]=='4')
num=num+4*pow(16,cd1-j);
else
if(str7[i]=='5')
num=num+5*pow(16,cd1-j);
else
if(str7[i]=='1')
num=num+1*pow(16,cd1-j);
else
if(str7[i]=='6')
num=num+6*pow(16,cd1-j);
else
if(str7[i]=='7')
num=num+7*pow(16,cd1-j);
else
if(str7[i]=='8')
num=num+8*pow(16,cd1-j);
else
if(str7[i]=='9')
num=num+9*pow(16,cd1-j);
else
if(str7[i]=='A')
num=num+10*pow(16,cd1-j);
else
if(str7[i]=='B')
num=num+11*pow(16,cd1-j);
else
if(str7[i]=='C')
num=num+12*pow(16,cd1-j);
else
if(str7[i]=='D')
num=num+13*pow(16,cd1-j);
else
if(str7[i]=='E')
num=num+14*pow(16,cd1-j);
else
if(str7[i]=='F')
num=num+15*pow(16,cd1-j);
}
3.2.2二进制转换为十进制
由二进制数转换成十进制数的基本做法是，把二进制数首先写成加权系数展开式，然后按十进制加法规则求和。

这种做法称为" 按权相加" 法。

本段程序的作用是将二进制转化为十进制，可作为二进制转化为其他进制的桥梁。

zj=num1;
result=0;
for(i=0;i<=cd;i++)
{
result=result+fmod((int)(zj),10)*pow(2,i);
zj=(int)(zj/10);
}
3.2.3八进制转换为十进制本段程序的作用是将八进制转化为十进制，可作为八进制转化为其他进制的桥梁。

zj=num1;
result=0;
for(i=0;i<=cd;i++)
{
result=result+fmod((int)(zj),10)*pow(8,i);
zj=(int)(zj/10);
}
3.3 一元多项式运算设计思路
输入多项式采用头插法的方式，输入多项式中一个项的系数和指数，就产生一个新的节点，建立起它的右指针，并用头节点指向它；为了判断一个多项式是否输入结束，定义一个结束标志，当输入非0 时就继续，当输入0时，就结束一个多项式的输入。

创建一元多项式的关键程序如下，由用户决定一元多项式的项数，项数系数和指数。

#in clude<stdlib.h>
#in clude<stdio.h>
#in clude<ctype.h>
typedef struct term{ //项的表示，多项式的项作为LinkList的数据元素
float coef; 〃系数
int exp n; // 指数
struct term *n ext;}term
term* CreatPolyn(term *P,int m) { //算法2.22〃输入m项的系数和指数，建立表示一元多
项式的有序链表P
if(m <= 0) return NULL;
term *h = P = (term*)malloc(sizeof(term)), *q;
P->coef = 0.0;
int i;
printf(”依次输入%d个非零项\n”,m);
for (i = 1; i <= m; ++i) { //依次输入m个非零项
sca nf("%f%d",&P->coef,&P->exp n);
if(P->coef)
q = P;P = P->n ext = (term*)malloc(sizeof(term));}
q-> next = NULL;
free(P);
return h;} // CreatPoly n
3.3.1 一元多项式的相加
它从两个多项式的头部开始，两个多项式的某一项都不为空时，如果指数相等的话，系数就应该相加；相加的和不为0的话，用头插法建立一个新的节点。

p的指数小于q的指数的话，就应该复制q节点到多项式中。

p的指数大于q的指数的话，就应该复制p节点到多项式中。

当第二个多项式空，第一个多项式不为空时，将第一个多项式用新节点产生。

当第一个多项式空，第二个多项式不为空时，将第二多项式用新节点产生。

一元多项式加法的关键程序如下：
term* APolyn(term *Pa, term *Pb) { // 算法 2.23// 多项式加法：Pa = Pa+ Pb，利用两个多项
式的结点构成”和多项式”。

term *h, *qa = Pa, *qb = Pb, *p, *q;
float sum;h = p = (term*)malloc(sizeof(term));p->n ext = NULL;
while (qa && qb) { // Pa 和Pb 均非空
switch (Compare(qa,qb)) {case -1: //多项式PA中当前结点的指数值小
p_>n ext = qb;p = qb;qb = qb->n ext;
break;
case 0: //两者的指数值相等
sum = qa->coef + qb->coef;
if (sum != 0.0) { //修改多项式PA中当前结点的系数值
p_>n ext = qa;qa->coef = sum;p = qa;qa = qa->n ext;}
else { 〃删除多项式PA中当前结点
q = qa;qa = qa->n ext;
ree(q);}
q = qb;qb = qb->n ext;
free(q);
break;
case 1: //多项式PB中当前结点的指数值小
p_>n ext = qa;p = qa;qa = qa->n ext;
break;} // switch
} // while
if (Pa) p->next = qa; //链接Pa中剩余结点
if (Pb) p->next = qb; //链接Pb中剩余结点
q = h;h = h->n ext;
free(q);
return h;} // APoly n
term* A(term *Pa, term *Pb) {
int n;
puts("再输入一一元多项式的项数");
scanf("%d",&n); 〃输入n
Pb = CreatPoly n(Pb, n);Pb = selsort(Pb);
PrintfPoly(Pa); 〃输出Poly(Pa)
if(Pb && Pb->coef>0) pri ntf(" + ");
Prin tfPoly(Pb);Pa = APoly n( Pa,Pb);
printf(” ="); 〃输出“=”
Pa = selsort(Pa);Pri ntfPoly(Pa);
return Pa;}
3.3.2 一元多项式的相减
它从两个多项式的头部开始，两个多项式的某一项都不为空时，如果指数相等的话，系数就应该相减；相加的和不为0的话，用头插法建立一个新的节点。

p的指数小于q的指数的话，就应该复制q节点到多项式中。

p的指数大于q的指数的话，就应该复制p节点到多项式中，并且建立的节点的系数为原来的相反数；当第二个多项式空，第一个多项式不为空时，将第一个多项式用新节点产生。

当第一个多项式空，第二个多项式不为空时，将第二个多项式用新节点产生，并且建立的节点的系数为原来的相反数。

一元多项式减法关键程序如下：term* BPoly
n(term *Pa, term *Pb) {
//多项式减法：Pa = Pa-Pb，禾U用两个多项式的结点构成”差多项式”。

term *p = Pb; 〃创建指针
while(p) {p->coef *= -1;p = p->n ext;}
return APo lyn( Pa,Pb);} // BPoly n
term* B(term *Pa, term *Pb)
{int n;
puts(”再输入一一元多项式的项数");
sca nf("%d",&n);
Pb = CreatPoly n(Pb, n);Pb = selsort(Pb);
Prin tfPoly(Pa);
printf(” -");
putchar('(');Pri ntfPoly(Pb);putchar(')');Pa = BPoly n( Pa,Pb); printf(” =");
Pa = selsort(Pa);Pri ntfPoly(Pa);
return Pa;}
第四章程序流程图
图2流程图
程序流程图的说明：首先开始后输出功能选择菜单，在选择菜单中 1 代表四则运算， 2 代表进制转换， 3 代表一元多项式的计算，0 表示退出。

当选择 1 时，调用四则运算程序，在四则运算程序中输出子菜单，根据提示选择要进行的算法，
输入数据得到运行结果出现问句是否结束运行是：结束，否：回到开始；当选择2时，调用进制转换程序，输出子菜单，根据提示选择进制转换，操作步骤同上；
当选择 3 时，调用一元多项式的计算程序，在子菜单中输入要计算的多项式，选
择要进行的加减运算，运行。

当选择0 时，结束程序。

第五章程序运行结果图
5.1四则运算运行结果
情选疑需要进行的运算类型
;蠶
L
情输入需要进行计算的数据
34 Z&
计算结果是：汝
anu kev to continue
图3四则运算结果
图3是四则运算运行结果，在主菜单中选择1基本四则运算，然后选择2 减法基本运算输入数据34 26即得到运行结果为8
5.2一元多项式加减运行结果
一元多项式计算土 事入一一元多项式的项数 靠次输入叶非零项 43 23 5 国22 & 5X^43+43X^23+23X^5
2 = (^ 斗乘
次輸入4个非零项
4 5£ 4
5 23
Q4 9五 45 23
6X^43*43X^23+23X^5 亠 68X 图4 一元多项式结果
图4是一元多项式运算结果，在主菜单中选3一元多项式运算，在提示下输 入3个非零项，得出运算结果，若还要继续运算则输入要输入的项数 4,再输入 4个非零项：34 56 45 23得出运算结果。

5.3运行初始状态
5初始菜单
图5为程序的初始状态及主菜单，在该对话框中选择要进行的功能
第六章总结
隔输入
元多项式的项数
=€8 X f ； +RX +13
运式 则
换项
序 四转务程 本制元出 基进一退
附录
附录一参考文献
[1] 严蔚敏. 数据结构. 北京：清华大学出版社，2010年
[2] 苏士华. 数据结构课程设计. 机械工程出版社
附录二程序源代码
#include<stdlib.h>
#include<stdio.h>
#include<ctype.h>
void computer1();
void computer2();
void computer3();
int sum(int x,int y); // 加
int substract(int x,int y);
int multipe(int x,int y);
int diver(int x,int y);
int BtoD(char*,char *);
typedef struct term { //项的表示，多项式的项作为LinkList 的数据元素float coef; //系数int expn; // 指数
struct term *next;
}term;
term* CreatPolyn(term *P,int m) { // 算法 2.22
// 输入m 项的系数和指数，建立表示一元多项式的有序链表P
if(m <= 0) return NULL;
term *h = P = (term*)malloc(sizeof(term)), *q; P->coef = 0.0;
int i; printf(" 依次输入%d 个非零项\n",m);
for (i = 1; i <= m; ++i) { // 依次输入m 个非零项
scanf("%f%d",&P->coef,&P->expn);
if(P->coef) q = P;
P = P->next = (term*)malloc(sizeof(term)); }
q->next = NULL; free(P);
return h;
} // CreatPolyn
term* selsort(term *h) { term *g, *p, *q; if(!h) return NULL;
float f; int i, fini = 1;
for(g = h;g->next&&fini;g = g->next) { fini = 0;
for(p = h,q = h->next;q;p = p->next,q = q->next) if (p->expn < q->expn) { f = p->coef;i = p->expn;
p->coef = q->coef;p->expn = q->expn; q->coef = f;q->expn = i;
fini = 1;
}
} for(g = h,p = g->next;p;) if(g->expn==p->expn) { g->coef += p->coef; g->next = p->next; q = p; p = p->next; free(q);
}
else if(g->next) { g = g->next; p = p->next;
}
return h;
}
void PrintfPoly(term *P) {
term *q = P;
if(!q) {
putchar('0');
return;
}
if(q->coef!=1) { printf("%g",q->coef);
if(q->expn==1) putchar('X');
else if(q->exp n) pri ntf("X A%d",q->exp n);
}
else if(!q->expn) putchar('1');
else if(q->expn==1) putchar('X');
else printf("XA%d",q->expn);
q = q->next;
while (q) {
if(q->coef > 0) putchar('+');
if(q->coef!=1) {
printf("%g",q->coef);
if(q->expn==1) putchar('X');
else if(q->expn) printf("XA%d",q->expn);
}
else if(!q->expn) putchar('1');
else if(q->expn==1) putchar('X');
else printf("XA%d",q->expn);
q = q->next;
}
}
Compare(term *a, term *b) {
if (a->expn < b->expn) return -1;
if (a->expn > b->expn) return 1;
return 0;
}
term* APolyn(term *Pa, term *Pb) { // 算法 2.23
〃多项式加法：Pa = Pa+ Pb,利用两个多项式的结点构成
"和多项式"。

term *h, *qa = Pa, *qb = Pb, *p, *q;
float sum;
h = p = (term*)malloc(sizeof(term));
p->next = NULL;
while (qa && qb) { // Pa 和 Pb 均非空
switch (Compare(qa,qb)) {
case -1: // 多项式 PA 中当前结点的指数值小 p->next = qb;
p = qb;
qb = qb->next; break;
case 0:
// 两者的指数值相等
sum = qa->coef + qb->coef; if (sum != 0.0) { // 修改多项式 PA 中当前结点的系数值 p->next = qa; qa->coef = sum;
p = qa;
qa = qa->next;
}
else { // 删除多项式 PA 中当前结点
q = qa;
qa = qa->next; free(q);
}
q = qb;
qb = qb->next;
free(q);
break;
case 1: // 多项式 PB 中当前结点的指数值小
p->next = qa;
p = qa; qa = qa->next; break;
} // switch
} // while
if (Pa) p->next = qa; if (Pb) p->next = qb; q = h;
h = h->next;
free(q);
return h;
} // APolyn term* A(term *Pa, term *Pb) {
int n;
puts(" 再输入一一元多项式的项数 "); scanf("%d",&n);
// 链接 Pa 中剩余结点
// 链接 Pb 中剩余结点
Pb = CreatPolyn(Pb,n);
Pb = selsort(Pb);
PrintfPoly(Pa);
if(Pb && Pb->coef>0) printf(" + ");
PrintfPoly(Pb);
Pa = APolyn(Pa,Pb); printf(" = ");
Pa = selsort(Pa);
PrintfPoly(Pa); return Pa;
}
term* BPolyn(term *Pa, term *Pb) { // 算法 2.23
//多项式减法：Pa = Pa-Pb ,禾U 用两个多项式的结点构成 term *p = Pb; while(p) { p->coef *= -1;
p = p->next;
} return APolyn(Pa,Pb);
} // BPolyn term* B(term *Pa, term *Pb) {
int n;
puts (”再输入一一元多项式的项数 ”)；
scanf("%d",&n);
Pb = CreatPolyn(Pb,n)；
Pb = selsort(Pb)；
PrintfPoly(Pa)； printf(" - ")； putchar('(')；
PrintfPoly(Pb)；putchar(')')； Pa = BPolyn(Pa,Pb)；
printf(" = ")；
Pa = selsort(Pa)；
PrintfPoly(Pa)； return Pa ；
}
term* CPolyn(term *Pa, term *Pb) {
// 算法 2.23 //多项式乘法：Pa = Pa*Pb ，利用两个多项式的结点构成
if(!Pb) return NULL ；
term *pa = Pa, *p, *q, *r, *s, *t ；
r = p = (term*)malloc(sizeof(term))； while(pa) {
p->coef = pa->coef; p->expn = pa->expn; q = p;
p = p->next = (term*)malloc(sizeof(term)); pa = pa->next;
} q->next = NULL; free(p);
pa = Pa;
t = s = (term*)malloc(sizeof(term)); while(pa) { q = s;
s = s->next = (term*)malloc(sizeof(term)); pa = pa->next;
} q->next = NULL; free(s); pa = Pa;
while(pa) { pa->coef *= Pb->coef; pa->expn += Pb->expn; pa = pa->next; }
Pb = Pb->next; while(Pb) { p = r; s = t;
"差多项式 "。

"积多项式 "。

while(p) { s->coef = p->coef * Pb->coef;
s->expn = p->expn + Pb->expn; p = p->next;
s = s->next;
}
Pa = APolyn(Pa,t); Pb = Pb->next;
} return Pa;
} // CPolyn
term* C(term *Pa, term *Pb) { int n;
puts(" 再输入一一元多项式的项数"); scanf("%d",&n);
Pb = CreatPolyn(Pb,n);
Pb = selsort(Pb); putchar('(');PrintfPoly(Pa);putchar(')'); printf(" * "); putchar('(');PrintfPoly(Pb);putchar(')'); printf(" = ");
Pa = CPolyn(Pa,Pb);
Pa = selsort(Pa);
PrintfPoly(Pa);
return Pa;
}
void main()
{
int i;
printf("1 、基本四则运算\n");
printf("2 、进制转换\n");
printf("3 、一元多项式运算\n");
printf("0 、退出程序\n"); scanf("%d",&i);
switch (i)
{
case 0: //退出
break;
case 1:
//调用四则运算函数computer1();
break;
case 2:
computer2();
//调用进制转换break;
case 3:
computer3();
//调用多项式运算break;
default:
break;
}
}
void computer3()
{
term *M,*N;
char s[2];
int i,n;
puts（" 一元多项式计算:\n 输入一一元多项式的项数"）; scanf（"%d",&n）; M = CreatPolyn（M,n）;
M = selsort（M）;
PrintfPoly（M）;
p: puts（"\n1:加\n2:减\n3:乘\n4:退出”）；
getchar（）;
q: gets（s）；
if（s[1]!='\0' || !isdigit（*s）） {
puts（"输入有误，请重新输入！”）;goto q;
}
i = *s-48;
switch（i） {
case 1:M = A（M，N）;goto p;;
case 2:M = B（M，N）;goto p;;
case 3:M = C（M，N）;goto p;
case 4:break;
default:puts（" 输入有误，请重新输入！"）;goto q;
}
}
void computer1（）
{
int i;
int a，b，c;
printf（" 请选择需要进行的运算类型\n"）;
printf（"1 加法\n"）;
printf（"2 减法\n"）;
printf（"3 乘法\n"）;
printf（"4 除法\n"）;
scanf（"%d"，&i）;
printf（" 请输入需要进行计算的数据\n"）;
scanf（"%d %d"，&a，&b）;
switch （i）
{
case 1:
c=sum（a，b）;
break;
case 2:
c=substract（a，b）;
break;
case 3:
c=multipe(a,b);
break;
case 4:
c=diver(a,b);
break;
default:
break;
}
printf(" 计算结果是：%d\n",c); }
void computer2()
{
}
int sum(int x,int y)
{
return x+y;
}
int substract(int x,int y)
{
return x-y;
}
int multipe(int x,int y)
{
return x*y;
}
int diver(int x,int y)
{
if (y!=0)
{
return x/y;
}
else
printf(" 输入非法！");
int BtoD(char * a,char *b) {
return 0;
}。