数据结构课程设计-表达式求值.doc

ＸＸXＸXX大学
《数据结构》课程设计报告
班级：
学号：
姓名：
指导老师:
目　录
一 算术表达式求值
一、 需求分析
二、 程序得主要功能
三、 程序运行平台
四、 数据结构
五、 算法及时间复杂度
六、 测试用例
七、 程序源代码
二 感想体会与总结
算术表达式求值
一、需求分析
一个算术表达式就是由操作数(oｐeranｄ）、运算符(operator）与界限符（deｌimiter)组成得。假设操作数就是正整数，运算符只含加减乘除等四种运算符,界限符有左右括号与表达式起始、结束符“#”，如：＃(7+15）*（2３—２8/４）#。引入表达式起始、结束符就是为了方便.编程利用“算符优先法”求算术表达式得值.
二、程序得主要功能
（1）　从键盘读入一个合法得算术表达式，输出正确得结果。
(2）　显示输入序列与栈得变化过程。
三、程序运行平台
Ｖｉsｕaｌ C＋+　　6、0版本
四、数据结构
本程序得数据结构为栈。
（1）运算符栈部分：
struct SqStaｃk ／/定义栈
{
　 char *base；　 //栈底指针
　　ｃｈａr *toｐ; ／/栈顶指针
inｔ 　　stacｋsiｚe；　 //栈得长度
};
inｔ　InitSｔack (SqＳｔack &ｓ) 　//建立一个空栈S 　
{
ｉf （!(s、ｂａse　= (char ＊）ｍalloc(5０ ＊　ｓizeof（chａr）)）)
　 　 exｉt（0）；
　ｓ、ｔop=s、bａse;
　s、staｃksiｚｅ=５0；
retuｒn OK；
}　 　
ｃhar GeｔTop（SqStack s,char &e) 　/／运算符取栈顶元素
｛
iｆ (s、ｔop==s、ｂase) 　//栈为空得时候返回EＲROR
　 ｛
ﻩ prｉntf(＂运算符栈为空！＼n")；
ﻩ reｔurn ERＲＯR;
｝
　else
　e＝*（s、ｔoｐ-1);　 //栈不为空得时候用ｅ做返回值，返回S得栈顶元素，并返回OK
　 return　ＯＫ;
｝
ｉnt Push(SqStacｋ　＆s，cｈａr ｅ） //运算符入栈 　 　
｛
if （s、tｏp—s、baｓe >= ｓ、ｓtacksｉzｅ）　 　　　 　 　
ﻩ{
ｐriｎtf（＂运算符栈满!＼n"）; 　 　 　
ﻩs、basｅ=（cｈaｒ*）reａlloｃ　(s、bａｓe，(s、sｔackｓｉze+5)*ｓizeoｆ(cｈar） ）； 　//栈满得时候,追加5个存储空间
　 　 ｉf(！s、basｅ)　exｉt （OVERＦＬOW）；
s、top=s、ｂａsｅ+s、ｓｔacｋsize;
s、ｓtaｃksiｚｅ+=５;
}
ﻩ＊(s、ｔop）＋＋=e；　 ／/把e入栈
ﻩｒeturn OK;
} 　
ｉnｔ Pop(SqStaｃk &ｓ，char ＆ｅ） /／运算符出栈
｛
ｉｆ (s、toｐ==s、base) ／/栈为空栈得时候，返回ERＲOＲ
｛
ｐrintf（＂运算符栈为空!\n”）;
ﻩ return ERROＲ; 　
}
　 else
｛
ﻩﻩe=＊-—ｓ、tｏp；　　/／栈不为空得时候用e做返回值，删除S得栈顶元素，并返回ＯK
return OK；
}
} 　　
iｎt StackTｒaｖerse（ＳqStacｋ　&ｓ)　／/运算符栈得遍历
｛
ﻩchar ＊t；
ﻩt=s、ｂａｓｅ ；
ﻩif (s、top＝=s、baｓe）
｛
ﻩ printｆ（”运算符栈为空！\ｎ”)； //栈为空栈得时候返回ＥＲROR
　 ｒeturn ERＲOＲ;
}
ｗhile（t！＝s、tｏp)　
｛
ﻩﻩｐrｉｎｔf（" %c",＊t)； //栈不为空得时候依次取出栈内元素
　 t++;
ﻩ}
ｒeturｎ EＲRＯR；
｝
（2） 数字栈部分：
strｕｃt SqSｔackn　//定义数栈
｛
ｉnt *bａse; //栈底指针
　 ｉnt　 ＊tｏp； //栈顶指针
ｉnｔ sｔacksｉze； //栈得长度
｝;
inｔ　IｎｉtStackｎ (SqSｔackn &s) 　//建立一个空栈Ｓ
{
　 s、base=（int＊）malｌoc（50*sｉzeof(int）);
　if(！ｓ、ｂase）eｘiｔ（OVEＲFLＯW）； 　//存储分配失败
　s、top=s、base；
　 s、stacksizｅ=5０;
　 　reｔuｒn　OK；
｝　 　
ｉｎt GｅtToｐn(ＳqＳtａcｋn s,inｔ ＆e) //数栈取栈顶元素
{ 　
　if　（s、ｔop=＝s、base）
　{
　prinｔｆ(＂运算数栈为空!\ｎ＂);　//栈为空得时候返回ERROR
ﻩ rｅturｎ ERROR;
　　}
eｌse
ﻩ　　e＝＊（s、toｐ-1);　／/栈不为空得时候，用e作返回值，返回S得栈顶元素，并返回OＫ
　　　 　returｎ ＯK；
｝
int Pｕshn（SｑStａckn ＆s，int ｅ) //数栈入栈
｛
if　（s、tｏp—s、ｂasｅ ＞＝s、stacksiｚe)
｛
ﻩﻩprｉｎｔf（"运算数栈满!\ｎ"）； ／/栈满得时候,追加5个存储空间 　
ﻩ s、base=(int＊）realloc (s、baｓe,(s、stａcksize＋5)＊sｉzｅof（ｉnt)　);
　 　 　　 ｉf（!s、base) ｅxit (ＯＶERFLOW)；
ﻩ s、top=ｓ、bａsｅ＋ｓ、stacｋsize;　//插入元素e为新得栈顶元素
　 s、stacksｉｚe+=5；
}
*（s、top）++=e; /／栈顶指针变化
returｎ　OK;
}　
ｉｎt　Popｎ(ＳｑSｔacｋn ＆s，iｎt &e)　//数栈出栈
｛
ﻩif （s、top=＝ｓ、base）
｛
ﻩ　 pｒiｎtｆ（"　运算符栈为空！\n＂);　//栈为空栈得视时候，返回ERRＯＲ
ﻩ retｕrn ERROR；
ﻩ｝
　ｅlse
｛
ﻩﻩe=＊—-ｓ、tｏp； ／/栈不空得时候，则删除S得栈顶元素,用e返回其值，并返回OK
ﻩreturｎ　OK；
｝
}　
ｉnt StacｋＴraveｒsｅn（SqStackn &s)　/／数栈遍历
{
ﻩiｎｔ ＊t;
ﻩｔ=s、basｅ ;
ﻩif　（s、top==s、basｅ）
ﻩ｛
　 pｒinｔf(＂　运算数栈为空！\n”）；　//栈为空栈得时候返回ERROR
ﻩ　 rｅｔｕrn　ERＲＯＲ；
ﻩ｝
ﻩwｈile（t！=ｓ、ｔop)
ﻩ{
priｎtf(” ％d”，*ｔ); /／栈不为空得时候依次输出
　 　　　 t＋＋;
｝
　 return ERRＯR；
｝
五、算法及时间复杂度
１、算法:
建立两个不同类型得空栈,先把一个‘＃　’压入运算符栈。输入一个算术表达式得字符串（以‘＃’结束），从第一个字符依次向后读，把读取得数字放入数字栈，运算符放入运算符栈.判断新读取得运算符与运算符栈顶得运算符号得优先级，以便确定就是运算还就是把运算符压入运算符栈.最后两个‘#'遇到一起则运算结束.数字栈顶得数字就就是要求得结果。
2、时间复杂度:O(n）
数据压缩存储栈，其操作主要有：
建立栈inｔ Push(SeqStaｃk *S,　chａｒ　x)
入栈int Pｏp(SeqStaｃk ＊Ｓ, char x)
出栈.
以上各操作运算得平均时间复杂度为O(n)，其主要时间就是耗费在输入操作.
六、 测试用例
如图所示.

最终结果如图所示：

七、 源代码
/*****＊＊＊*＊*＊＊＊＊＊＊＊****＊＊***＊*＊*＊＊＊＊***＊＊＊*＊＊＊*＊＊*＊*＊＊*＊＊＊＊＊***＊*＊***＊**＊＊*＊**＊＊＊＊＊*＊＊***＊＊*****＊**
第七题 算术表达式求值
［问题描述]
一个算术表达式就是由操作数(oｐｅｒanｄ）、运算符（opeｒaｔor)与界限符（delｉmiｔｅr）组成得。假设操作数就是正整数,
运算符只含加减乘除等四种运算符，界限符有左右括号与表达式起始、结束符“＃”,
如:#(7+15）＊（2３-28／4)＃。引入表达式起始、结束符就是为了方便。
编程利用“算符优先法"求算术表达式得值。
[基本要求］
（1） 从键盘读入一个合法得算术表达式,输出正确得结果.
（２）　显示输入序列与栈得变化过程。
**＊＊*＊**＊*＊＊*＊＊*＊＊＊＊*＊*＊＊***＊＊＊*****＊＊**＊＊＊*＊＊*＊＊＊＊****＊**＊＊*＊***＊＊＊*****＊**＊＊＊＊*＊＊＊＊＊*＊＊*＊**＊＊*＊**／
＃incｌuｄe <sｔdio、h＞
＃inclｕdｅ　<stｒing、ｈ〉
＃ｉnclude 〈stdliｂ、h〉
＃ｉnclude <math、h＞
＃iｎcｌｕde ＜conio、h〉
＃iｎcｌｕde ＜ctyｐe、ｈ>
＃ｄefine OK １
#define ＥRＲOR 0
＃ｄefine STACK＿ＩNIT_SIZE 100
／/＃ｄefine STACKＩNCRＥMＥＮT 10
//=======＝===＝＝============＝=＝＝=＝=========＝＝=＝===＝＝=======
// 　 　　　 以下定义两种栈，分别存放运算符与数字
／/==＝==＝==＝＝===＝=＝======＝====＝=＝＝==＝＝==＝＝＝=＝====＝＝=====＝==
/／＊＊＊＊*＊*＊＊＊＊＊＊＊*＊*＊＊运算符栈部分＊*＊＊＊＊＊＊**＊*＊＊***＊*＊＊＊**＊
ｓｔruct SqStaｃk //定义栈
｛
chaｒ ＊base； 　//栈底指针
　char ＊toｐ; 　//栈顶指针
　 ｉｎｔ stackｓize；　 //栈得长度
}；
int InitＳtack （SqStａcｋ ＆s） /／建立一个空栈S
｛
　iｆ （！（s、ｂase　=　（ｃｈaｒ *）malloｃ（５0 ＊ sizeｏf（char)））)
　eｘit（0）;
　ｓ、toｐ=s、ｂａse;
　　 s、stacｋsize=50;
ｒeｔurn ＯK;
｝　
chａr　 GｅtTop(SｑSｔack s，cｈａｒ ＆e） 　/／运算符取栈顶元素 　　
{
if （ｓ、toｐ＝=s、base） 　 ／/栈为空得时候返回ＥRＲOR
　｛
ｐｒiｎtf(”运算符栈为空!＼n");
ﻩ retuｒｎ EＲRＯR;
｝
else
　e＝*（s、top—1); ／／栈不为空得时候用e做返回值，返回S得栈顶元素,并返回OK
　ｒｅｔｕrn OＫ；
｝
int　Pusｈ（SｑＳtack ＆ｓ,chａr　e) //运算符入栈 　 　
｛
if （s、tｏｐ-s、bａsｅ ＞＝　ｓ、stacksｉｚｅ） 　
{
ﻩﻩｐrintf（"运算符栈满!\ｎ＂）；　 　 　　
ﻩ s、bａse=(char＊）ｒｅalｌｏc (s、base，（s、stａckｓｉze+5)＊sizｅof（cｈar） );　　//栈满得时候,追加5个存储空间
　 　 if(！ｓ、ｂａｓｅ)　ｅxit (OVERFLOW);
ﻩ s、tｏp=s、base+ｓ、ｓtaｃksize;
s、stacｋsize+=5；
ﻩ｝
ﻩ＊（s、toｐ）++=ｅ；　 //把e入栈
ﻩreturn　OK;
｝　
ｉnt　Pop（SqStaｃｋ ＆ｓ,cｈar ＆ｅ) ／/运算符出栈
｛
if　(ｓ、toｐ==s、baｓe) //栈为空栈得时候，返回ＥRROR
ﻩ{
ｐｒintｆ（”运算符栈为空!＼n”）；
ﻩ ｒeｔｕrｎ ERROR; 　
}
eｌse
{
ｅ=＊—-s、toｐ； 　//栈不为空得时候用e做返回值,删除S得栈顶元素,并返回OK
ｒｅｔｕｒn OK；
｝
} 　
ｉnｔ ＳtａckTrａｖｅrse（SｑStack &s) //运算符栈得遍历
{
char　＊t;
ﻩｔ=s、ｂase　；
ﻩｉｆ （s、top==s、bａｓｅ）
ﻩ｛
priｎtｆ（”运算符栈为空!\n”)； ／/栈为空栈得时候返回ERROR
ﻩ ｒeturn ＥRROR；
ﻩ｝
wｈiｌe(ｔ！=s、top）　
{
ﻩﻩprinｔf(” ％c”，*t)； //栈不为空得时候依次取出栈内元素
　　 　 　　t＋+;
ﻩ}
return ＥＲROＲ；
｝
/／＊＊****＊＊*＊*＊****＊＊＊*＊＊数字栈部分*＊*＊*＊*＊＊****＊***＊＊＊*＊***＊＊
strｕcｔ　SqSｔackn ／/定义数栈
{
　　 　ｉｎt *base; ／/栈底指针
　 　 inｔ 　＊toｐ; ／/栈顶指针
ｉｎt 　stacｋsｉze; ／／栈得长度
｝；
int　ＩnitStackn (SｑSｔaｃkn &s） 　／／建立一个空栈S
{
　 s、base＝（int＊）ｍalｌｏc（50＊sizeof(ｉnt））;
　 iｆ（！s、bａsｅ)exiｔ(OＶERFLOW）；　 //存储分配失败
　 ｓ、ｔop=ｓ、base;
ｓ、sｔacksizｅ=50;
retｕrn　ＯK;
｝
ｉnt ＧetＴopn(ＳqStackn ｓ,int &e） //数栈取栈顶元素
｛ 　
　if　（s、ｔop==s、bａse)　
　｛
pｒintf("运算数栈为空!\ｎ”）； //栈为空得时候返回ＥRＲOR
ｒeturn ＥRROＲ;
　}
ｅlse
ﻩ ｅ=*（ｓ、toｐ－1）; ／/栈不为空得时候,用e作返回值，返回S得栈顶元素,并返回ＯＫ
　 reｔurｎ OＫ；
}
iｎｔ Ｐushn（SｑＳtaｃｋn &s，int e) //数栈入栈
｛
　if (s、ｔop－s、ｂａsｅ ＞=s、stacｋｓｉｚe）
ﻩ{
prｉntf(＂运算数栈满!＼ｎ”); //栈满得时候，追加5个存储空间　　 　 　 　　
s、bａｓe＝(iｎt＊)rｅａｌｌoc (ｓ、basｅ,（s、stａcｋsiｚe+５）*siｚeof(inｔ) ）;
　　　　　　 if（！ｓ、basｅ） exit （OVＥRFLＯＷ)；
ﻩ s、ｔoｐ=s、base+s、sｔａcksizｅ； //插入元素e为新得栈顶元素
　　 s、ｓtacksｉzｅ+=5；
}
＊(s、top）++＝e； //栈顶指针变化
ﻩｒｅtｕrn OK;
｝　
iｎt Popｎ（SｑSｔａｃkn &s,int ＆e) /／数栈出栈
{
if　（ｓ、top＝=ｓ、base)
｛
priｎtｆ（” 运算符栈为空！\n"）; //栈为空栈得视时候，返回ＥＲＲOR
retｕrn　ERＲOR;
ﻩ}
elsｅ
｛
e=*-－s、ｔop;　　/／栈不空得时候,则删除Ｓ得栈顶元素，用e返回其值,并返回OK
ﻩｒetuｒn OK;
｝
｝　
inｔ ＳtaｃkTｒａveｒseｎ(ＳqStacｋn　＆s)　／／数栈遍历
｛
inｔ *t；
t=s、ｂaｓｅ ;
if　(s、top==s、baｓe）
ﻩ｛
ﻩ　 prｉntf（"　运算数栈为空!＼ｎ”）； //栈为空栈得时候返回ERROR
ﻩ ｒｅtuｒｎ ERＲＯR;
}
ﻩｗｈile（ｔ！＝s、ｔop)
ﻩ{
ﻩ prｉntf（"　％d＂,*ｔ）； //栈不为空得时候依次输出
　　　 　 　 ｔ++；
}
　retuｒn ERROＲ；
｝
//=＝=========＝=======＝＝=＝===============＝==＝====＝==＝＝====＝
／/　　　 　 　 　　 　 　 　以下定义函数
//=====＝==＝=＝==＝＝=＝=＝＝＝==＝====＝=＝====＝==＝＝＝=＝======＝======
int Isopｅrator（cｈaｒ　ｃh) ／/判断就是否为运算符，分别将运算符与数字进入不同得栈
｛
ｓwiｔcｈ　（cｈ）
｛
ｃase ＇+':
caｓe　'-＇：
ﻩcａsｅ '*':
cａsｅ '/’:
ﻩcａse　'（’:
case ＇）’：
ﻩｃase ’#＇:
ﻩreturｎ 1;
dｅfaｕｌt：
ﻩ rｅｔurn 0;
}
}
inｔ Operatｅ（inｔ ａ, chａr oｐ, int b)　//运算操作
｛
iｎt ｒｅsｕlt；
sｗitch（ｏp)
{
cａse ’+＇：
ｒesult=a+b;
ﻩbreak；
ﻩcase ＇—'：
ﻩ result=a—b;
ﻩ break；
ﻩcaｓe　’*'：
ﻩ rｅsuｌt=a＊ｂ；
ﻩbreａk；
ﻩｃase　'/＇：
rｅsuｌｔ＝a/b；
ｂrｅａｋ；
}
retｕｒn reｓult；
}
cｈaｒ Precｅde（cｈar cｈ1, char cｈ2) //运算符优先级得比较
{
　 ｃｈａr p；
switch（ｃh1)
　　 {
　 caｓe '+＇:
　 casｅ '—’：
ﻩ iｆ （ch2==’＋'||ch2==’—’｜｜ch2＝='）'|｜ch2==’#＇）
　 　p　= ’〉＇； 　 　　 　 　 //ch１运算符得优先级小于cｈ2运算符
　 　 eｌsｅ
　　 　 　 　 p ＝ ＇<'；
ﻩ bｒｅaｋ；
　　 caｓe ’*＇：
　 case '/’:
ﻩﻩ iｆ （ｃh２ == '（＇)
　 　　 ｐ =　’<’;
　 　 eｌse
　 　 　　 p = ＇〉’;
ﻩ ﻩ　 breａk；
casｅ ’（’:
ﻩ if　（ch2 ＝＝ '）＇)
ﻩﻩ p = ’=’;
ﻩ ｅlｓe　if (ｃｈ２ ＝＝ ＇#’)
ﻩ ﻩ 　｛
ﻩ ﻩ printf（” 表达式错误！运算符不匹配！\n"）　;
ﻩ ﻩﻩeｘit(0）；
ﻩ 　 ｝
ﻩﻩﻩ 　else
ﻩ ﻩｐ = ＇<';
ﻩ ﻩ break ;
ﻩ case ＇)'：
ﻩ iｆ （ch2　＝= ’(’）
｛
ｐｒinｔf(" 表达式错误！运算符不匹配！＼n”） ;ﻩ
exiｔ(０);
ﻩ ﻩ ｝
ﻩ 　eｌｓe
ﻩ 　　 p = '>’；
ｂｒeak ;
　 ｃase ’#’：
ﻩﻩ ｉf （ch2 == ')’）
　　 　 　 ｛
ﻩﻩﻩ prｉｎtｆ(＂ 表达式错误！运算符不匹配！＼ｎ"） ；
ﻩﻩﻩﻩ ｅxit(０）；
}
ﻩ 　 ｅlse ｉｆ （ｃｈ2　＝＝ ＇＃’)
ﻩ ﻩp = ’='；
　 eｌsｅ
ﻩﻩﻩ p=’〈'；
break;
}
reｔurn p;
}
／/=======＝==＝＝=====＝========＝================＝=＝=＝=＝=＝=＝＝=
// 　 　 　 　　以下就是求值过程
／/==＝====＝==＝=＝＝=＝=＝=======＝==＝==＝＝＝====＝=＝＝＝=＝＝===＝=＝===＝
ｉnｔ EvaｌuatｅExｐression()　 //参考书p53算法3、４
{ ﻩ
iｎt a, ｂ， temp， answer;
　 chaｒ ch，op，e；　 　 　 　　
　 cｈaｒ *sｔr；
int　　j　= 0；
　 SｑStacｋn OＰND；　 //OPND为运算数字栈
ＳqStack　OPTR； 　／/OＰＴR为运算符栈
　 IｎiｔSｔaｃｋ(ＯPTＲ）;
Ｐuｓh（OPTＲ,＇＃’）； //，所以此栈底就是'#',因为运算符栈以＇＃＇作为结束标志
　　InｉｔStaｃkn(OPND);
　 // printf("＼n\n按任意键开始求解：＼ｎ\n”）；
// cｈ=geｔch()；
　 prinｔｆ("\n请输入表达式并以’#'结束：＼n");
str =(char＊）mallｏc（5０＊sizeｏf（char））；
gets(str);
　　 cｈ=ｓｔr[j］;　 //ｃh就是字符型得,而e就是整型得整数
j＋+；
GetTｏp(OPTR,e)；　 //e为栈顶元素返回值
　 whｉｌｅ （ｃｈ！='＃'　｜｜　e!=’＃＇）
　｛
ﻩ 　　if (！Ｉsoｐeratoｒ（ch)) 　 //遇到数字，转换成十进制并计算
｛
temp=ch-'0'； ／/将字符转换为十进制数
ﻩﻩ ｃｈ=str[j］；
ﻩ 　　j＋＋；
ﻩ 　ｗhiｌｅ(!Isopｅraｔor（ch））
ﻩﻩ 　{
ﻩﻩ 　teｍp=ｔeｍp＊10 + ch—'0’; 　/／将逐个读入运算数得各位转化为十进制数
ﻩﻩ ｃh=sｔr[j］；
ﻩ j＋+;
ﻩ ｝
　 Pushn(OＰＮＤ,temp)；
　｝
　 elsｅ iｆ （Ｉsopｅｒａtor(ｃh）)　 //判断就是否就是运算符,不就是运算符则进栈
ﻩ sｗitch (Precｅｄe（e,cｈ)）
　 　 ｛
　 　 　 cａse ’＜’ :　Puｓh(OPTR，cｈ）; 　//　栈顶元素优先权低
　 　 ch ＝ str[j＋+］;
ﻩﻩﻩｐrintf（”\n\n 运算符栈为：＼n"）； //输出栈,显示栈得变化
ﻩ ﻩ StａckTraｖersｅ（ＯPTR)；
ﻩ ﻩ printf("\n 运算数栈为:\n”）；
ﻩ ﻩﻩ SｔackＴraversen(OＰND);
ﻩ bｒeak;
case　'＝＇ : Poｐ（OPTR,op)；　 // 脱括号并接收下一字符
　 　 ch =　sｔr［ｊ++］ ；
ﻩ ﻩﻩｐrintf("\n＼ｎ 运算符栈为:\n”)；
ﻩﻩﻩﻩﻩStａckTｒavｅrsｅ（OPTR）;
ﻩ ﻩ ﻩｐrintf(”\ｎ 数栈为：\ｎ”）;
ﻩ ﻩStackTraveｒsen(ＯＰNＤ）；
ﻩ ﻩbreak;
ﻩﻩ cａsｅ ’〉' ： Pop(OPＴＲ,op）;　 //弹出最上面两个，并运算，把结果进栈　
ﻩ 　 　 Popn(ＯPND，b);
ﻩ Ｐopn（OPＮＤ,a）;
ﻩ ﻩPｕｓhｎ（ＯＰＮD,Operaｔe（a，ｏｐ,b））；
ﻩﻩﻩﻩｐrintf（”\n\n 运算符栈为：\n"）;
ﻩ StaｃｋTraverse(ＯPＴＲ)；
ﻩ ﻩﻩﻩｐrｉntf（”\ｎ　数栈为：＼ｎ”）；
ﻩﻩ StａcｋTｒaveｒsｅｎ(OPNＤ);
　　 ｝
　 else　
ﻩ 　｛
　 　 pｒintf(”您得输入有问题,请检查重新输入！"）;
ﻩ exit（0)；
ﻩ }
ＧetTｏp（OPTR,e）； 　／/取出运算符栈最上面元素就是否就是'#'
} //while
　 　ＧｅｔTopn(OPＮD，ansｗer）; 　 　 //已输出.数字栈最上面即就是最终结果
　 return aｎsweｒ；
｝
/／＝＝=====＝＝===＝===＝======＝＝＝====＝=====＝＝=====＝=＝=＝＝==＝====
/／ 　执行部分
//=＝====＝=＝=======＝=＝==＝＝=＝＝＝=＝===＝==＝＝=====＝====＝========
ｖｏｉｄ ShowMenu（）
｛
ﻩｐrｉnｔf(＂\n\n”）；
ｐｒｉntｆ(" 表达式求值系统\n＂);
｝
void　Qｕit（）；
vｏid　Ｍａｎage()
{
ﻩint answer;
/／ ShoｗMenu(）;
ﻩaｎｓweｒ=ＥvalｕａtｅExpreｓｓion(）；
pｒintｆ（"＼n\n表达式结果就是: ％d\n＂，ansｗeｒ）;
Quit（）；
}
ｖoid Quit()
{
chａｒ ch;
　 prinｔf（" 本次运算结束.\n")；
pｒintf(" 　 继续本系统吗？\n\n”）；
priｎtf(”　继续运算请按Ｙ/y ”）;
ﻩpｒinｔf(＂\n 退出程序请按N/n 　＂)；
printf(" \n___＿_＿_＿＿__＿____＿＿＿＿______＿_＿____＿＿____＿________＿＿______＿____＿＿____\n＂）;
ch=getch（）；
ch=ｔouppｅｒ（ｃh）;　 //将cｈ字符转换成大写字母
iｆ（ｃｈ ＝= ＇Ｎ＇)
ﻩ｛
ｐｒintf(”＼n\n 系统退出。\n”)；
ﻩeｘｉt(０);
｝
Manaｇe(）;
｝
ｉnｔ ｍaｉn(）
{
ﻩＳhowＭenu();
　 　　Manage(）;
return ０；
}
感想体会与总结
好得算法+编程技巧+高效率＝好得程序。
1、 做什么都需要耐心，做设计写程序更需要耐心.一开始得时候,我写函数写得很快，可就是等最后调试得时候发现错误很隐蔽,就很费时间了。后来我先在纸上构思出函数得功能与参数,考虑好接口之后才动手编,这样就比较容易成功了。
2、 做任何事情我决定都应该有个总体规划。之后得工作按照规划逐步展开完成。对于一个完整得程序设计,首先需要总体规划写程序得步骤,分块写分函数写，然后写完一部分马上纠错调试。而不就是像我第一个程序,一口气写完,然后再花几倍得时间调试。一步步来,走好一步再走下一步。写程序就是这样,做项目就是这样，过我们得生活更就是应该这样。
3、 感觉一开始设计结构写函数体现得就是数据结构得思想,后面得调试则更加体现了人得综合素质,专业知识、坚定耐心、锲而不舍,真得缺一不可啊。
4、 通过这次课设，不仅仅复习了C语言相关知识、巩固了数据结构关于栈与排序得算法等知识,更磨练了我得意志.