C语言 后缀表达式计算文档格式.docx
《C语言 后缀表达式计算文档格式.docx》由会员分享，可在线阅读，更多相关《C语言 后缀表达式计算文档格式.docx（23页珍藏版）》请在冰豆网上搜索。
stdio、h>
/*导入需要用到的各种包*/
stdlib、h>
string、h>
typedefstruct/*定义结构体用来存储操作符*/
{
charop;
/*存储字符*/
intlevel;
/*存储优先级*/
}OpNode;
typedefstruct
OpNodeop[100];
inttop;
intsize;
/*表示栈内元素的个数*/
}stack;
/*定义符号栈*/
voidinit（stack*st）/*初始化栈*/
st->
size=0;
top=0;
}
OpNodepop（stack*a）/*出栈*/
if（a->
size==0）/*如果栈为空结束操作*/
{
exit（-1）;
}
a->
size--;
returna->
op[--（a->
top）];
/*取出栈顶元素*/
voidpush（stack*a,OpNodeop）/*入栈函数*/
size++;
op[（a->
top）++]=op;
OpNodetop（stack*a）/*观察栈顶函数*/
printf（"
stackisempty\n"
）;
}
top）-1];
/*只得到栈顶的值而不出栈*/
typedefstruct/*定义数值栈*/
doublenum[100];
/*栈顶指针*/
}numstack;
voidinit2（numstack*st）/*初始化数值栈*/
doublepop2（numstack*a）/*数值栈出栈*/
size==0）/*出栈前的判空*/
num[--（a->
/*得到栈顶的值*/
voidpush2（numstack*a,doublenum）/*入栈*/
num[（a->
top）++]=num;
voidmain（）/*主函数*/
voidchange（charstr[],charexp[]）;
/*声明要用到的各个函数*/
doubleCalResult（charexp[]）;
/*声明后缀表达式的计算函数*/
doubleDirectcalresult（charstr[]）;
intcheck（charstr[],charchestr[100]）;
charstr[100],exp[100],chestr[100];
/*str存储原算术表达式,exp存储对应的printf（"
算术表达式为:
\n"
后缀表达式,chestr存储容错字符'
^'
*/
gets（str）;
if（check（str,chestr））/*调用容错函数*/
{printf（"
表达式错在:
%s\n"
str）;
printf（chestr）;
/*根据输入情况指出错误的地方*/
exit（-1）;
change（str,exp）;
/*调用函数将中缀转化为后缀*/
后缀表达式为:
exp）;
运算结果为:
%f\n"
CalResult（exp））;
/*调用函数计算后缀表达式*/
printf（"
直接运算的结果为:
Directcalresult（str））;
/*调用直接计算函数*/
voidchange（charstr[],charch[]）/*将前缀表达式转化为后缀表达式*/
inti=0;
/*str的索引*/
intk=0;
charc;
/*字符串中取出的放在C中*/
stackst;
OpNodeop;
OpNodeops;
init（&
st）;
/*初始化符号栈*/
c=str[i++];
while（c!
='
\0'
）/*对字符串进行扫描*/
if（（c>
0'
&
c<
9'
）||c=='
、'
）/*如果字符为数字或小数点*/
{
while（（c>
）
{
ch[k++]=c;
/*将字符直接放入数组中*/
c=str[i++];
}
ch[k++]='
|'
;
/*在其后面放入一个分隔符*/
}
if（c=='
（'
）/*如果字符就是左括号*/
{
op、op='
op、level=-1;
/*定义其优先级为-1*/
push（&
st,op）;
/*将左括号直接入栈*/
if（c=='
）'
）/*如果字符为右括号*/
op=top（&
/*首先观察栈顶*/
while（st、size!
=0&
op、op!
）/*如果不就是左括号并且栈不为空*/
op=pop（&
/*出栈并存入数组中*/
ch[k++]=op、op;
if（st、size>
0）/*再次检查栈就是否为空,*/
op=top（&
elsebreak;
/*为空就结束*/
}
pop（&
/*去掉左括号*/
+'
||c=='
-'
）/*如果就是+-号*/
op、op=c;
op、level=1;
/*优先级为1*/
if（st、size==0）
push（&
/*如果此时栈为空直接入栈*/
else
ops=top（&
/*观察栈顶*/
while（ops、level>
=op、level）/*如果栈顶优先级高*/
{
ops=pop（&
ch[k++]=ops、op;
/*将栈顶元素取出存入数组中*/
if（st、size>
0）
ops=top（&
/*进行判空操作,栈为空结束*/
else
break;
}
/*此时栈顶优先级低,入栈*/
*'
%'
）/*如果就是*/进行*/
op、op=c;
op、level=2;
if（st、size==0）
if（st、size>
ops=top（&
else
break;
}
/*索引自加检索下一个字符*/
while（st、size!
=0）/*最后判断栈如果不为空*/
ops=pop（&
/*取出栈内元素存入数组中*/
ch[k++]=ops、op;
ch[k]='
/*将\0作为结尾存入数组*/
doubleCalResult（charexp[]）/*后缀表达式的计算*/
numstacknumst;
/*建立数值栈*/
doubled1,d2,dr;
/*后缀表达式的索引*/
/*将字符转化为浮点数的索引*/
char*s;
chartrans[100];
/*存字符表示的一段数字*/
init2（&
numst）;
/*实现数值栈*/
c=exp[k++];
）/*开始扫描后缀表达式*/
）/*如果就是操作符*/
switch（c）
case'
:
/*如果就是加法操作*/
d2=pop2（&
d1=pop2（&
dr=d1+d2;
/*相加后入栈*/
push2（&
numst,dr）;
break;
/*如果就是减法操作*/
dr=d1-d2;
/*相减后入栈*/
/*如果就是乘法操作*/
dr=d1*d2;
/*相乘后入栈*/
/*如果就是除法操作*/
dr=d1/d2;
/*相除后入栈*/
/*如果就是取余操作*/
dr=（double）（（int）d1%（int）d2）;
/*类型转化并取余后入栈*/
}
if（c>
）/*如果就是字符表示的数字*/
while（c>
）
trans[i++]=c;
/*将字符存入数组进行下一个的扫描*/
c=exp[k++];
trans[i++]='
/*将表示数字的字符串结束*/
i=0;
s=trans;
/*将指针指向该数组*/
d1=atof（s）;
/*利用函数将字符串转化为浮点数*/
push2（&
numst,d1）;
c=exp[k++];
returnpop2（&
/*最后结果将在数值栈中,取出作为返回值*/
doubleDirectcalresult（charstr[]）/*表达式的直接计算出结果*/
stackms;
/*建立符号栈*/
numstackmns;
doublecalculate（doubleod1,doubleod2,OpNodeop）;
intindex=0;
intlen=strlen（str）;
/*存放数值的一段字符*/
/*trans的索引*/
char*s;
doubled;
OpNodetempn;
/*存放当前扫描的操作符*/
OpNodetempln;
doubleoda,odb,odr;
doubleresult;
/*作为返回值返回结果*/
init（&
ms）;
/*实现两个栈*/
init2（&
mns）;
while（index<
len）/*开始对用户输入的表达式进行扫描*/
c=str[index++];
if（c>
）/*如果就是数字字符或小数点*/
trans[i++]=c;
/*将其存入数组扫描下一个*/
c=str[index++];
trans[i++]='
/*扫描完一个数结束数组*/
/*索引归0*/
s=trans;
d=atof（s）;
push2（&
mns,d）;
/*转化为浮点数入栈*/
if（c=='
）/*如果就是+-*/
tempn、level=1;
/*优先级设为1*/
tempn、op=c;
if（ms、size==0）
ms,tempn）;
/*栈为空直接入栈*/
templn=top（&
while（templn、level>
=tempn、level）/*栈顶优先级高*/
templn=pop（&
/*取出操作数与操作符计算*/odb=pop2（&
oda=pop2（&
odr=calculate（oda,odb,templn）;
push2（&
mns,odr）;
/*结算结果入栈*/
if（ms、size>
{
templn=top（&
/*如果栈空结束*/
}
else
break;
/*操作符入栈*/
）/*如果就是*/%操作*/
tempn、level=2;
/*定义优先级为2*/
/*栈空直接入栈*/
/*取出操作数与操作符计算*/
odb=pop2（&
if（ms、size>
push（&
）/*如果就是左括号*/
tempn、level=-1;
tempn、op=c;
/*直接入栈优先级定位-1*/
）/*如果就是右括号*/
while（tempn、op!
）/*遇到左括号结束*/
/*从数栈中取两个数,从符号栈里取操作符*/
/*计算出结果入栈*/
if（ms、size>
tempn=top（&
/*取出左括号*/
tempn=top（&
while
（1）
{
odb=pop2（&
oda=pop2（&
push2（&
if（ms、size>
tempn=top（&
else
break;
result=pop2（&
/*最后的结果在数值栈中返回*/
returnresult;
doublecalculate（doubleod1,doubleod2,OpNodeop）/*已知操作符与操作数的计算*/
{
switch（op、op）
case'
returnod1+od2;
returnod1-od2;
/*判断操作符就是哪个执行相应计算*/
returnod1*od2;
returnod1/od2;
return（double）（（int）od1%（int）od2）;
return0;
/*如果上面的都没有执行返回0*/
intcheck（charstr[],charchestr[100]）/*容错函数*/
charcdivide;
stackche;
/*括号匹配用到的栈*/
OpNodetemp;
/*chestr的索引*/
intisinteger（charinteger[100]）;
/*%计算就是判断就是否就是整数*/
chars1[10];
/*%操作时存储%左右的数字*/
chars2[10];
intindexs1=0;
/*s1s2的索引*/
intindexs2=0;
che）;
intflag=0;
/*0——没有出错1——有错*/
inttag=0;
c=str[i];
/*开始扫描*/
intj;
/*数组chestr索引*/
for（j=0;
j<
99;
j++）
chestr[j]='
'
/*数组初始化待以后加入'
chestr[j]='
while（c!
）/*如果就是左括号就入栈*/
{
temp、op=c;
che,temp）;
if（che、size>
/*栈不为空就取出一个左括号*/
flag=1;
p
升级会员 