数据结构与算法分析课程设计报告.docx

数据结构与算法分析课程设计报告.docx

《数据结构与算法分析课程设计报告.docx》由会员分享，可在线阅读，更多相关《数据结构与算法分析课程设计报告.docx（18页珍藏版）》请在冰豆网上搜索。

数据结构与算法分析课程设计报告

《数据结构与算法分析》课程设计报告

课题名称：

带括号的算术表达式求值

实验报告

一、实验一:

带括号的算术表达式求值

二、实验的目的和要求:

1.采用算符优先数算法,能正确求值表达式;

2.熟练掌握栈的应用;

3.熟练掌握计算机系统的基本操作方法,了解如何编辑、编译、链接和运行一个C++程序;

4.上机调试程序,掌握查错、排错使程序能正确运行。

三、实验的环境:

指硬件和软件环境

硬件环境：

CPU:

IntelPentium Processor1.00GHz;1.99GHz,2.00GB的内存

软件环境：

MicrosoftWindowsXP；MicrosoftVisualC++6.0.

四、算法描述:

可用特殊符号加自然语言或算法框图（程序流程图、PAD图等）或伪语言（likeC++）。

声明一个link类，用于存放链式栈的结构，然后构造一个链式栈，继承并实现栈。

然后建立calculator类。

在calculator类中：

1.定义一个操作符栈和一个操作数栈；

StackOPND;操作数栈；

StackOPTR;操作符栈

2.辅助函数：

intisp（charop）;//栈内优先数

inticp（charop）;//栈外优先数

boolGet2Operands（double&x,double&y）;//从栈中取出两个操作数

boolDoOperator（charop）;//形成运算指令，进行运算

voidGetChar（char&ch）;//从输入流获取一字符ch,并跳过空格及回车

boolIsOperator（charch）;//判断ch是否为操作符

3.另外的成员函数：

run（）;

五、源程序清单:

1.LK_STACK.H

template

structNode{

//datamembers

Node_entryentry;

Node*next;

//constructors

Node（）;

Node（Node_entryitem,Node*add_on=NULL）;

};

template

classStack{

public:

//StandardStackmethods

Stack（）;

boolempty（）const;

Error_codepush（constStack_entry&item）;

Error_codepop（）;

Error_codetop（Stack_entry&item）const;

voidclear（）;

//Safetyfeaturesforlinkedstructures

~Stack（）;

Stack（constStack&original）;

voidoperator=（constStack&original）;

protected:

Node*top_node;

};

template

Node:

:

Node（）

{

next=NULL;

}

template

Node:

:

Node（Node_entryitem,Node*add_on）

{

entry=item;

next=add_on;

}

template

Stack:

:

Stack（）

{

top_node=NULL;

}

template

boolStack:

:

empty（）const

{

if（top_node==NULL）

returntrue;

else

returnfalse;

}

template

Error_codeStack:

:

push（constStack_entry&item）

/*

Post:

Stack_entryitemisaddedtothetopof

theStack;returnssuccessorreturnsacode

ofoverflowifdynamicmemoryisexhausted.

*/

{

Node*new_top=newNode（item,top_node）;

if（new_top==NULL）returnoverflow;

top_node=new_top;

returnsuccess;

}

template

Error_codeStack:

:

pop（）

/*

Post:

ThetopoftheStackisremoved.IftheStack

isemptythemethodreturnsunderflow;otherwiseitreturnssuccess.

*/

{

Node*old_top=top_node;

if（top_node==NULL）returnunderflow;

top_node=old_top->next;

deleteold_top;

returnsuccess;

}

template

Error_codeStack:

:

top（Stack_entry&item）const

{

Error_coderesult;

if（empty（））

returnunderflow;

else{

item=top_node->entry;

returnsuccess;

}

}

template

voidStack:

:

clear（）//clearelememt

/*

Post:

TheStackiscleared.

*/

{

while（!

empty（））

pop（）;

}

template

Stack:

:

~Stack（）//Destructor

/*

Post:

TheStackiscleared.

*/

{

clear（）;

}

template

Stack:

:

Stack（constStack&original）//copyconstructor

/*

Post:

TheStackisinitializedasacopyofStackoriginal.

*/

{

Node*new_copy,*original_node=original.top_node;

if（original_node==NULL）top_node=NULL;

else{//Duplicatethelinkednodes.

top_node=new_copy=newNode（original_node->entry）;

while（original_node->next!

=NULL）{

original_node=original_node->next;

new_copy->next=newNode（original_node->entry）;

new_copy=new_copy->next;

}

}

}

template

voidStack:

:

operator=（constStack&original）//Overloadassignment

/*

Post:

TheStackisresetasacopyofStackoriginal.

*/

{

Node*new_top,*new_copy,*original_node=original.top_node;

if（original_node==NULL）new_top=NULL;

else{//Duplicatethelinkednodes

new_copy=new_top=newNode（original_node->entry）;

while（original_node->next!

=NULL）{

original_node=original_node->next;

new_copy->next=newNode（original_node->entry）;

new_copy=new_copy->next;

}

}

while（!

empty（））//CleanoutoldStackentries

pop（）;

top_node=new_top;//andreplacethemwithnewentries.

}

2.Utility.h

#include//standardstringoperations

#include//standardiostreamoperations

#include//numericlimits

#include//mathematicalfunctions

#include//fileinputandoutput

#include//characterclassification

#include//dateandtimefunction

#include//coninputandoutput

enumError_code{success,fail,underflow,overflow};

//enumbool{false,true};

3.Calculator.h

template

classCalculator{

public:

voidRun（）;//执行表达式

private:

StackOPND;//操作数栈

StackOPTR;//操作符栈

intisp（charop）;//栈内优先数

inticp（charop）;//栈外优先数

boolGet2Operands（double&x,double&y）;//从栈中取出两个操作数

boolDoOperator（charop）;//形成运算指令，进行运算

voidGetChar（char&ch）;//从输入流获取一字符ch,并跳过空格及回车

boolIsOperator（charch）;//判断ch是否为操作符

};

template

voidCalculator:

:

Run（）

{

OPND.clear（）;OPTR.clear（）;

charch,OPTR_top,prior_char,op;doubleoperand;

OPTR.push（'='）;

prior_char='=';//prior_char表示输入的前一个字符，如为数，则令其值为'0'

GetChar（ch）;

OPTR.top（OPTR_top）;

if（OPTR.top（OPTR_top）==underflow）

{

cout<<"表达式有错!

"<

return;

};

while（OPTR_top!

='='||ch!

='='）

{

if（isdigit（ch）||ch=='.'）

{

cin.putback（ch）;

cin>>operand;

OPND.push（operand）;

prior_char='0';

GetChar（ch）;

}

elseif（!

IsOperator（ch））

{

cout<<"表达式中出现非法字符!

"<

while（cin>>ch,ch!

='='）;

return;

}

else

{

if（（prior_char=='='||prior_char=='（'）&&（ch=='+'||ch=='-'））OPND.push（0）;

if（isp（OPTR_top）

{

OPTR.push（ch）;

prior_char=ch;

GetChar（ch）;

}

elseif（isp（OPTR_top）>icp（ch））

{

OPTR.top（op）;OPTR.pop（）;

if（!

DoOperator（op））return;

}

elseif（isp（OPTR_top）==icp（ch）&&ch=='）'）

{

OPTR.pop（）;

prior_char='）';

GetChar（ch）;

};

};

if（OPTR.top（OPTR_top）==underflow）

{

cout<<"表达式有错!

"<

return;

};

}

if（OPND.top（operand）==underflow||OPTR.pop（）==underflow）

{

cout<<"表达式有错!

"<

return;

}

else

{//栈OPND与OPTR.中只能有一个元素

OPND.pop（）;

if（OPND.pop（）==success||OPTR.pop（）==success）

{

cout<<"表达式有错!

"<

return;

}

cout<

return;

}

};

template

intCalculator:

:

isp（charop）

{

intresult;

switch（op）

{

case'=':

result=0;

break;

case'（':

result=1;

break;

case'^':

result=7;

break;

case'*':

case'/':

case'%':

result=5;

break;

case'+':

case'-':

result=3;

break;

case'）':

result=8;

}

returnresult;

};

template

intCalculator:

:

icp（charop）

{

intresult;

switch（op）

{

case'=':

result=0;

break;

case'（':

result=8;

break;

case'^':

result=6;

break;

case'*':

case'/':

case'%':

result=4;

break;

case'+':

case'-':

result=2;

break;

case'）':

result=1;

}

returnresult;

};

template

boolCalculator:

:

Get2Operands（double&x,double&y）

{

if（OPND.empty（））

{

cout<<"表达式有错!

"<

returnfalse;

}

OPND.top（y）;OPND.pop（）;

if（OPND.empty（））

{

cout<<"表达式有错!

"<

returnfalse;

}

OPND.top（x）;OPND.pop（）;

returntrue;

};

template

boolCalculator:

:

DoOperator（charop）

{

Data_elementx,y;

boolresult=Get2Operands（x,y）;

if（result==true）

{

switch（op）

{

case'+':

OPND.push（x+y）;

break;

case'-':

OPND.push（x-y）;

break;

case'*':

OPND.push（x*y）;

break;

case'/':

if（y==0）

{

cout<<"除数为零!

"<

returnfalse;

}

OPND.push（x/y）;

break;

case'%':

if（（long）y==0）

{

cout<<"除数为零!

"<

returnfalse;

}

OPND.push（（long）x%（long）y）;

break;

case'^':

OPND.push（pow（x,y））;

}

returntrue;

}

elsereturnfalse;

};

template

voidCalculator:

:

GetChar（char&ch）

{

cin>>ch;

while（ch==''||ch=='\n'）

cin>>ch;

};

template

boolCalculator:

:

IsOperator（charch）

{

if（ch=='='||ch=='（'||ch=='^'||ch=='*'||

ch=='/'||ch=='%'||ch=='+'||ch=='-'||ch=='）'）

returntrue;

else

returnfalse;

};

4.Calculator.cpp

#include"Utility.h"

#include"Lk_stack.h"

#include"Calculator.h"

main（）

{

Calculators;

chariscontinue='Y';

inti;

while（iscontinue=='Y'）

{

cout<<"输入表达式（以等号“=”结束）:

"<

s.Run（）;

cout<<"是否继续（Y/N）?

";

cin>>iscontinue;

iscontinue=toupper（iscontinue）;

}

}

六、运行结果:

七、实验运行情况分析（包括算法、运行结果、运行环境等问题的讨论）。

1．第一次正常输入表达式：

“（34-5）*2=”

正确得到结果58；

2.除数为零时，输出错误信息；

3.输入的表达式错误时，输出错误信息。