数据结构实验1线性结构.docx

数据结构实验1线性结构.docx

《数据结构实验1线性结构.docx》由会员分享，可在线阅读，更多相关《数据结构实验1线性结构.docx（31页珍藏版）》请在冰豆网上搜索。

数据结构实验1线性结构

哈尔滨工业大学计算机科学与技术学院

实验报告

课程名称：

数据结构与算法

课程类型：

必修

实验项目名称：

线性结构及其应用

实验题目：

算术表达式求值

班级：

1203105

学号：

19

姓名：

朱泽圻

设计成绩

报告成绩

指导老师

目录

一、实验目的2

二、实验要求及实验环境2

1.实验要求：

2

2.实验环境2

三、设计思想3

1．逻辑设计3

（1）stack3

（2）Main4

（3）Translation14

（4）Translation25

2．物理设计5

2．物理设计6

四、测试结果11

五、系统不足与经验体会12

六、附录：

源代码（带注释）13

一、实验目的

通过利用堆栈解决问题，熟悉线性表逻辑结构与存储结构，并尝试进行简单应用。

二、实验要求及实验环境

1.实验要求：

（1）从键盘输入任意一个语法正确的（中缀）表达式，显示并保存该表达式。

（2）利用栈结构，把上述（中缀）表达式转换成后缀表达式，并显示栈的状态变化过程和所得到的后缀表达式。

（3）利用栈结构，对上述后缀表达式进行求值，并显示栈的状态变化过程和最终结果。

2.实验环境

Code：

：

Blocks10.05

工作语言：

C++

三、设计思想

（本程序中的用到的所有数据类型的定义，主程序的流程图及各程序模块之间的调用关系）

1．逻辑设计

（1）stack

>>MemberData:

DataTypedata[maxi]

Positiontop

>>MemberFunctions:

GetTop（）//Returnthetopofthestack.

StackPop（）//Returnanddeletethetopofthestack.

StackPush（DataTypex）//Pushavalueintothestack.

IsEmpty（）//Judgeifthestackisempty.

（2）Main

（3）Translation1

（4）Translation2

2．物理设计

详细设计内容见附录。

此处只介绍实数转换：

boolTranslation2（）

{

cout<<"Expressiontranslater2:

symbolsandoperaters."<

<<"Inputyourexpression,endwitha'#'."<

charFl[maxi];//以此存储每个时刻读取的小数的字符串表示

floatFlArray[maxi];//以此储存总共读入的所有小数

inti;

for（i=0;i

{

Fl[i]=0;

FlArray[i]=0.0;

}

//==============================================================

//Translation2-Part1:

Reading

DataTypeDataTran,CharIn;

intj=0;

boolIsFloat=0;

//DataTranandCharIntakethesameresponsibilityasthose

//inTranslation1.

//iisthecountofFl[maxi],andshowthelastdigit's

//positioninFl[maxi].

//jisthecountofFlArray[maxi],andshowsthelastfloat

//numberspositioninFlArray[maxi].

//IsFloatshowstheworkingmodeofreadingpart.Ifit's

//valueis1,thenreadingpartisproducingfloat

//numbers;else,it'sproducingoperators.

cin>>CharIn;

i=0;

j=0;

do{

if（（（CharIn>='0'）&&（CharIn<='9'））||（CharIn=='.'））

{

Fl[i]=CharIn;

IsFloat=1;

i++;

}

//Ifadigitisread,thentheprocessionoffloatnumbers

//readingshouldbestarted.

//Therefore,IsFloatshouldbeset.

//Then,CharInshouldbewrittenintoFl[i].

//Sinceonemoredigitisread,ishouldbeaddedby1.

elseif（IsFloat==1）

{

FlArray[j]=atof（Fl）;

OutStack.StackPush（'$'）;//以此表示实数占据的位置

IsFloat=0;

j++;

for（i=0;i

{

Fl[i]=0;

}//以此重置字符串

i=0;

}

//IfCharIndoesn'tconsistofafloatnumber,thenthe

//processionoffloatnumbersreadingshouldbeended.

//Sincetheformerprocessionended,ishouldbereset.

//Thencurrentfloatnumberasastringshouldbeturninto

//afloatvalue,andbewrittenintoFlArray[j].

//Sinceonemorevalueisread,jshouldbeaddedby1.

//Torepresentthefloatnumber,a'$'shouldbepushinto

//OutStack.

if（CharIn=='#'）break;

//'#'showsthatoriginalexpressionisended.

switch（CharIn）

{

case'（':

{

OprStack.StackPush（CharIn）;

break;

}

//When'（'isread,pushitintoOprStackdirectly.

//####Accordingtofollowingstatement,therecanbenomore

//than2operatorsabovea'（'.

case'）':

{

while（（OprStack.GetTop（）!

='（'）&&（OprStack.IsEmpty（）==0））

{

DataTran=OprStack.StackPop（）;

OutStack.StackPush（DataTran）;

}

OprStack.StackPop（）;

break;

}

//When'）'isread,popalloperatorsabovethefirst'（'

//inOprStackintoOutStack,anddeletethefirst'（'.

case'+':

case'-':

{

while（（OprStack.GetTop（）!

='（'）&&（OprStack.IsEmpty（）==0））

{

DataTran=OprStack.StackPop（）;

OutStack.StackPush（DataTran）;

}

OprStack.StackPush（CharIn）;

break;

}

//When'+'or'-'isread,popalloperatorsabovethe

//first'（'inOprStackintoOutStack,andthenpush

//CharInintoOprStack.

//####Since'+'and'-'areofthelowestpriority,they

//cannotbeplacedevenabovethemselves,forthey're

//totherightofformeroperators.

case'*':

case'/':

{

if（（OprStack.GetTop（）=='*'）||（OprStack.GetTop（）=='/'））

{

DataTran=OprStack.StackPop（）;

OutStack.StackPush（DataTran）;

}

OprStack.StackPush（CharIn）;

break;

}

//When'*'or'/'isread,ifthetopofOprStackis'*'

//or'/',popthetopofOprStackintoOutStackand

//thenpushCharInintoOprStack.

//####Since'*'and'/'areofthehighestpriority,onlywhen

//they'retotherightofthemselves,shouldformertopbe

//popintoOutStack.Andit'seasytoconcludethatthe

//topofOprStackcanholdnomorethanone'*'or'/'.

}

cin>>CharIn;

//Continuetheprocessuntiltheendofformerexpression.

}while

（1）;

while（OprStack.IsEmpty（）==0）

{

DataTran=OprStack.StackPop（）;

OutStack.StackPush（DataTran）;

}

//Yet,eventheoriginalexpressionended,it'spossibleforOprStack

//tohold1or2operators.

//Translation2-Part2:

Calculating

intFloatNum=0;

j--;//以此使实数数组游标所指元素即为输出栈最上方实数

//FloatNumshowsthenumberofcontinuousfloatnumbers.

//####Actually,jisstillinuse,andj+1pointsatthelastfloat

//number,soweshouldreduceitby1.

do{

if（（OutStack.GetTop（）=='+'）||（OutStack.GetTop（）=='-'）||

（OutStack.GetTop（）=='*'）||（OutStack.GetTop（）=='/'））

{

DataTran=OutStack.StackPop（）;

OprStack.StackPush（DataTran）;

FloatNum=0;

}

//AnewreadoperatorshouldbepushedintoOprStackbefore

//calculation.

//Ifanoperatorisread,thenthere'snocontinuousfloatnumbers,

//soFloatNumshouldbereset.

elseif（OutStack.GetTop（）=='$'）

{

FloatNum++;

OutStack.StackPop（）;

}

//'$'representFlArray[j].

while（FloatNum==2）

//OnlyWhenthere'stwocontinuousfloatnumbers

//arefoundcanthecalculationbestarted!

//####Astwocontinuousfloatnumbersarefound,

//current'$'representsFlArray[j-1].

{

DataTran=OprStack.StackPop（）;

switch（DataTran）

{

case'+':

{

FlArray[j-1]=FlArray[j-1]+FlArray[j];

break;

}

case'-':

{

FlArray[j-1]=FlArray[j-1]-FlArray[j];

break;

}

case'*':

{

FlArray[j-1]=FlArray[j-1]*FlArray[j];

break;

}

case'/':

{

FlArray[j-1]=FlArray[j-1]/FlArray[j];

break;

}

}

j--;//以此将游标定位到实数数组前一位

if（j==0）//此时只有最后一个实数，即为最终结果

{

FloatNum=1;

};

}

}while（OutStack.IsEmpty（）==0）;

cout<

return0;

}

四、测试结果

1.2+4.3=5.5

4.5*6.3=28.35

多次输入时程序出错

五、系统不足与经验体会

1.反复输入数据时可能出错，说明内部结构尚不完善

2.无法识别非法输入，不能及时提示

3.不能识别负数

六、附录：

源代码（带注释）

#include

#include

usingnamespacestd;

constintmaxi=100;

typedefcharDataType;

typedefintPosition;

typedefclassstack

{

public:

stack（）;

~stack（）;

boolMakeNull（）;//Makethestackempty.

DataTypeGetTop（）;//Returnthetopofthestack.

DataTypeStackPop（）;//Returnanddeletethetopofthestack.

boolStackPush（DataTypex）;//Pushavalueintothestack.

boolIsEmpty（）;//Judgeifthestackisempty.

private:

DataTypedata[maxi];

Positiontop;

}STAK;

stack:

:

stack（）

{

inti;

for（i=0;i

{

data[i]=0;

}

top=-1;

}

stack:

:

~stack（）

{

}

boolstack:

:

MakeNull（）

{

inti;

if（top==-1）

{

cout<<"Emptystack."<

return0;

}

for（i=0;i<=top;i++）

{

data[i]=0;

}

top=-1;

return0;

}

DataTypestack:

:

GetTop（）

//Return'@'ifthestackisempty,

//returndata[top]ifthestackisnotempty.

{

if（top==-1）

{

return'@';

}

else

{

returndata[top];

}

}

DataTypestack:

:

StackPop（）

//Return-1ifthestackisempty,

//minustopby1andreturndata[top+1]ifthestackisnotempty.

{

if（top==-1）

{

cout<<"Emptystack."<

return-1;

}

top--;

returndata[top+1];

}

boolstack:

:

StackPush（DataTypex）

//Return-1ifthestackisfull,

//addtopby1andsetdata[top]asxifthestackisnotfull.

{

if（top==maxi-1）

{

cout<<"Fullstack1."<

return-1;

}

top++;

data[top]=x;

return0;

}

boolstack:

:

IsEmpty（）

//Return1ifthestackisempty,

//return0ifthestackisnotempty.

{

if（top==-1）

{

return1;

}

else

{

return0;

}

}

//======================================

stackOprStack,OutStack;

//OprStack:

thestacktosaveoperators.

//OutStack:

thestacktosavethefinalexpression.

boolTranslation1（）

{

cout<<"Expressiontranslator1:

symbolsandoperators."<

<<"Inputyourexpression,endwitha'#'."<

charCharIn;

DataTypeDataTran;

cin>>CharIn;

//CharInisthearchcharacter.

do{

if（CharIn=='#'）break;

//'#'showsthatoriginalexpressionisended.

if（（（CharIn>='a'）&&（CharIn<='z'））

||（（CharIn>='A'）&&（CharIn<='Z'）））

{

OutStack.StackPush（CharIn）;

}

//Whenlettersareread,pushthemintoOutStackdirectly.

//Asforoperators:

switch（CharIn）

{

case'（':

{

OprStack.StackPush（CharIn）;

break;

}

//When'（'isread,pushitintoOprStackdirectly.

//####Accordingtofollowingstatement,therecanbenomore

//than2operatorsabovea'（'.

case'）':

{

while（（OprStack.GetTop（）!

='（'）&&（OprStack.IsEmpty（）==0））

{

DataTran=OprStack.StackPop（）;

OutStack.StackPush（DataTran）;

}

OprStack.StackPop（）;

break;

}

//When'）'isread,popalloperatorsabovethefirst'（'

//inOprStackintoOutStack,anddeletethefirst'（'.

case'+':

case'-':

{

while（（OprStack.GetTop（）!

='（'）&&（OprStack.IsEmpty（）==0））

{

DataTran=OprStack.StackPop（）;

OutStack.StackPush（DataTran）;

}

OprStack.StackPush（CharIn）;

break;

}

//When'+'or'-'isread,popalloperatorsabovethe

//first'（'inOprStackintoOutStack,andthenpush

//CharInintoOprStack.

//####Since'+'