数据结构表达式自动计算实验报告

目 录

一、设计思想……………………………………………………….03 二、算法流程图…………………………………………………….04 三、源代码………………………………………………………….07 四、运行结果……………………………………………………….22 五、遇到的问题及解决…………………………………………….23 六、心得体会……………………………………………………….23

1

用两种方法实现表达式自动计算

一、 设计思想

程序代码使用两种算法实现输入表达式的自动计算，准确计算出表达式的值。

第一种方法：将中缀表达式转变为后缀表达式，然后对后缀表达式进行计算。 具体思想：

1、 中缀表达式转换为后缀表达式：在主函数中通过gets()方法一次性将输入表达式读

入expression数组中，然后调用ChangeExpression()方法进行表达式的转换。首先，定义一个操作符栈，并将其初始化，定义两个循环变量。利用While循环扫描所输入的表达式，对所扫描的每个元素进行判断。

(1)：若扫描为数字或小数点，则将所扫描元素赋值给字符数组change[] (2)：若扫描为操作符：则先判断操作符栈是否为空，若为空，则直接压入操作符栈。若不为空，将change[]数组中加个$符号，用于后面计算时扫描整个数字，然后判断当前所扫描元素是否为右括号，若是右括号，则判断栈顶元素是否为左括号，若是，将左括号弹出操作符栈；若栈顶元素不是左括号，则用While循环将栈顶元素弹出，直到栈顶元素为左括号，然后将左括号弹出操作符栈。若当前所扫描元素不是右括号，则调用操作符优先级比较函数比较当前所扫描元素与栈顶元素的优先级：如果所扫描元素的优先级高于栈顶元素时，将所扫描元素直接入栈；如果当前所扫描元素优先级低于栈顶元素时，判断栈顶元素是否为左括号，若是，当前扫描元素直接入栈，若不是，则栈顶元素出栈进数组，直到所扫描元素高于栈顶元素的优先级为止，然后将当前所扫描元素直接入操作符栈。本次循环结束，i++，进行下一次循环，直到遇见\\0，While循环结束。

最后判断操作符栈是否为空，若不为空，则将操作符栈中操作符全部弹出，赋给数组。

2、 后缀表达式计算：定义一个数字栈，并将数字栈初始化为空。定义一个临时存放数

数字的字符型数组str[]，定义一个指向临时数组的指针*str，定义循环变量。利用While循环扫描数组：首先判断当前所扫描元素是否为$符号，若是，则i++；若不是，则判断当前扫描元素是否为数字或小数点，若是，则循环扫描整个数字，以便数字为小数时获得一个完整的小数。将扫描数字赋给str[]数组，然后利用st=str令指针指向临时数组str[]，利用atof()函数将字符型转为浮点型，并压入数字栈。若扫描不是数字或小数点，弹出两个数字一个操作符，调用SymbolCal(float popNum1, float popNum2, char popSymbol2)函数进行计算，将计算结果压入数字栈。注意：判断当前元素是否为$符号，若是则不进行弹出计算操作。数字栈栈顶元素即为运算结果 ，弹出返回。

第二种方法：直接计算法。 具体思想：

在主函数中对Calculate()函数进行声明，然后调用Calculate()函数进行操作。在Calculate()中定义一个expression[MaxSize]数组，获取输入的表达式，利用gets()函数，将表达式一次性获取。定义两个栈，数字栈和操作符栈，并分别初始化为空，定义临时存放数字的数组str[MaxSize]数组，定义指针*str，定义循环变量。利用While循环扫描整个表达

2

用两种方法实现表达式自动计算

式：当所扫描为数字或小数点时，进行循环扫描，以便可以获取整个数字(尤其是小数),将扫描元素赋给字符数组str[]，令指针st指向str[]数组，利用atof()函数,将字符型转换为浮点型，并且压入数字栈。若当前所扫描元素不为数字或小数点(即操作符)，判断操作符栈是否为空，若空，则直接入栈。若不为空，判断当前所扫描元素是否为左括号，

若是左括号，则直接入操作符栈。若不为空且当前元素不为左括号，判断当前所扫描元 素是否为右括号，若是右括号，判断栈顶元素是否为左括号，当是左括号时，弹出左括号。若不是左括号，则弹出两个数字，弹出一个操作符进行计算，将结果压入数字栈。直到栈顶元素为左括号，然后弹出左括号。若操作栈不为空、当前元素不为左括号且当前元素不为右括号，调用优先级比较函数StackMatchPre(char entry1,char entry2)比较当前扫描元素与栈顶元素。当优先级高时直接压入操作符栈，当优先级相同或低于栈顶元素的优先级时，判断栈顶元素是否为左括号，若是，则直接入栈。若不是，则弹出两个数字，弹出一个操作符进行计算，将结果压入数字栈，直到当前扫描元素的优先级高于栈顶元素的优先级且操作符栈不为空。本次While循环结束，i++，进行下一次While循环，直到遇见\\0，While循环结束。最后判断操作符栈栈顶是否为空，若不为空，则弹出两个数字，弹出一个操作符进行计算，计算结果压入数字栈。直到操作符栈为空。将数字栈栈顶弹出赋值给一个浮点型变量，将此变量返回，即为最终计算结果。

二、 算法流程图

1、 下面是中缀转后缀表达式的算法流程图

3

用两种方法实现表达式自动计算

主函数通过gets()获取输入的表达式调用中缀转后缀函数While循环判断输入的表达式是数字是操作符放入字符型数组判断操作符类型(添加分隔符)是”(”操作符出栈，直到遇到“)”优先级低比较优先级是直接入栈栈顶是否为”(”优先级高直接入栈否栈顶元素出栈，在比较优先级

图1：中缀转后缀算法流程图

4

用两种方法实现表达式自动计算

后缀表达式数字While循环判断字符转为浮点型，压入数字栈数字栈弹出两个数字，操作符栈弹出操作符，计算，结果进数字栈最终结果出栈，并返回 图2：后缀表达式计算流程图

2、 直接计算法的流程图

5

用两种方法实现表达式自动计算

主函数调用Calculate()函数调用gets()函数获取表达式操作符是数字While循环判断字符是”)”\\0循环扫描，转为浮点型压入栈中将操作符栈全部弹出，与数字栈数字做计算，返回最终结果判断操作符类型弹出操作符与数字计算，直到栈顶为”(”优先级高比较优先级直接入栈优先级低是判断是否”(”直接入栈否栈顶元素出栈，数字栈弹出两个数字计算，结果进数字栈，在比较优先级 图3：直接计算法算法流程图

三、 源代码

1、下面给出的是用中缀转后缀算法实现的程序的源代码：

#include #include #include

6

#include

#define MaxSize 100

用两种方法实现表达式自动计算

//定义操作符栈，用来临时存放转后缀表达式的操作符 typedef struct stackSymbol {

int top;

char entry[MaxSize];

}stackSymbol;

//定义数值栈，用来第二次扫描后缀表达式时存放数字 typedef struct stackNum {

int top;

float item[MaxSize];

}stackNum; //初始化操作符栈

void CreatStackSymbol(stackSymbol *s) { }

//初始化数字栈

void CreatStackNum(stackNum *s) { }

//判断栈是否已满：StackNumIsFull(),StackSymbolIsFull() int StackNumIsFull(stackNum *s) { }

int StackSymbolIsFull(stackSymbol *s) {

if(s->top==(MaxSize-1)) {

printf(\"\\n The StackSymbol is Full\\n\"); return 0;

if(s->top==(MaxSize-1)) { } else { }

return 1;

printf(\"The StackNum is Full\\n\"); return 0; s->top=-1;

s->top=-1;//栈为空时top为-1

7

}

} else { }

return 1;

用两种方法实现表达式自动计算

//判断栈是否为空：StackNumIsEmpty(),StackSymbolIsEmpty(); int StackNumIsEmpty(stackNum *s) { }

int StackSymbolIsEmpty(stackSymbol *s) { }

//将操作符压入操作符栈

int PushStackSymbol(stackSymbol *s,char entry) {

if(!StackSymbolIsFull(s)) { } else { }

s->top++;//先进行++操作，在使用top(-1时为空) s->entry[s->top]=entry; return 1; return 0; if(s->top==-1) { } else { }

return 1;

printf(\"\\n The StackSymbol is Empty\\n\");

return 0; if(s->top==-1) { } else { }

return 1;

printf(\"\\n The StackNum is Empty\\n\"); return 0;

8

}

//将数字压入数字栈

用两种方法实现表达式自动计算

int PushStackNum(stackNum *s,float item) { }

//将符号弹出栈

char PopStackSymbol(stackSymbol *s) { }

//讲数字弹出栈

float PopStackNum(stackNum *s) { }

//定义优先级函数(对每个字符定义不同的优先级) int StackPre(char entry) {

switch (entry) //根据不同的字符设置不同的优先级 {

if(!StackNumIsEmpty(s)) { } else { }

return s->item[s->top--]; return 0;

if(!StackSymbolIsEmpty(s)) { } else { }

return s->entry[s->top--]; return 0; if(!StackNumIsFull(s)) { } else { }

s->top++;//先进行++操作，在使用top(-1时为空) s->item[s->top]=item; return 1; return 0;

9

}

case '+': }

return 1; break; return 1; break; return 2; break; return 2; break; return 3; break; return 0;

用两种方法实现表达式自动计算

case '-':

case '*':

case '%':

case '(':

case ')': default:

printf(\"\\n The symbol is Error\\n\"); break;

//定义优先级的比较函数：StackMatchPre() int StackMatchPre(char entry1, char entry2) { }

//定义表达式转换函数：ChangeExpression()

void ChangeExpression(char expression[], char change[]) {

int pre1=StackPre(entry1); //调用stackPre函数，对操作符做出级别的认定 int pre2=StackPre(entry2);

if((pre1-pre2)>0) //根据差值来确定优先级：1表示entry1优先级高；0表示优先级相同；-1{ }

else if((pre1-pre2)==0) { }

else if((pre1-pre2)<0) { }

return -1; return 0; return 1;

表示entry2优先级高

10

用两种方法实现表达式自动计算

stackSymbol sSymbol;//定义一个操作符栈

CreatStackSymbol(&sSymbol);//将定义的操作符栈初始化 int i=0;//定义循环变量 int j=0;

while(expression[i]!='\\0')//以'\\0'为条件，循环控制扫描表达式 {

if(((expression[i]>='0')&&(expression[i]<='9'))||(expression[i]=='.'))//当所扫描元素为数字或小数点{ } else {

change[j++]='$';//添加'$'作为分隔符，以便扫描小数

if(sSymbol.top==-1)//当所扫描字符为操作符且当前操作符栈为空时，将操作符直接入栈 { } else {

if(expression[i]==')') //当是右括号且当前操作符栈不为空，则将操作符栈元素弹出，直到遇到'('，将左括号弹出

PushStackSymbol(&sSymbol,expression[i]);

change[j]=expression[i]; j++;

时将元素进数组

{ } else {

int lev=StackMatchPre(expression[i],sSymbol.entry[sSymbol.top]);//比较所扫描元 if(lev==1)//当所扫描元素优先级高于栈顶元素时，所扫描元素直接入栈 { }

else //当所扫描元素优先级低于栈顶元素时，判断栈顶是不是左括号，若是，则{

PushStackSymbol(&sSymbol,expression[i]);

while(sSymbol.entry[sSymbol.top]!='(') { }

PopStackSymbol(&sSymbol);//将左括号弹出

change[j]=PopStackSymbol(&sSymbol); j++;

素与栈顶元素的优先级

所扫描元素入栈，若不是，则栈顶元素出栈进数组，到所扫描元素优先级高于栈顶元素为止

while((StackMatchPre(expression[i],sSymbol.entry[sSymbol.top])<=0)&&(sSymbol.top!=-1))

11

}

} { }

} i++;

}

}

}

{ }

用两种方法实现表达式自动计算

if(sSymbol.entry[sSymbol.top]=='(') { } else { }

change[j]=PopStackSymbol(&sSymbol); j++;

break;

PushStackSymbol(&sSymbol,expression[i]);//扫描元素压栈

while(sSymbol.top!=-1)//将操作符栈中的操作符全部pop出，赋给数组

change[j]=PopStackSymbol(&sSymbol); j=j+1;

change[j]='\\0';//添加'\\0',以便对数组进行第二次扫描

//定义根据操作符两两计算的函数：SymbolCal()

float SymbolCal(float popNum1, float popNum2, char popSymbol2) {

switch(popSymbol2)//根据每个不同的操作符，进行不同操作

{ case '+':

return popNum1+popNum2; break;

return popNum2-popNum1; break;

return popNum2/popNum1; break;

return popNum1*popNum2; break;

return (int)popNum2%(int)popNum1;

case '-':

case '/':

case '*':

case '%':

12

}

}

用两种方法实现表达式自动计算 break; break;

default : printf(\"Please enter correct symbol;\");

//定义后缀表达式的计算函数：Calculate() float Calculate(char cal[]) { 数

}

else //根据操作符做相应运算，并将运算结果入栈 {

if(cal[i]!='$')//将$排除，扫描为$时，不进行弹出运算操作 {

float popNum1=PopStackNum(&sNum);//弹出两个数，一个操作符，进行计算 float popNum2=PopStackNum(&sNum);

float calResult=SymbolCal(popNum1,popNum2,cal[i]); PushStackNum(&sNum,calResult);

//将结果压栈

{ }

str[j]='\\0';//变为字符串 j=0; st=str;

float atofNum=atof(st);//将字符型转换为浮点型 PushStackNum(&sNum,atofNum);//将数字压栈

i++; j++;

str[j]=cal[i];

stackNum sNum; //定义一个数字栈 CreatStackNum(&sNum);//初始化数字栈 char str[MaxSize];//用于临时存储数字的数组 char *st;//指向临时数组的指针 int i=0;//循环变量的定义 int j=0;

while(cal[i]!='\\0')//while循环控制扫描整个表达式 {

if(cal[i]=='$')//用$分割扫描每个数字 { }

if(((cal[i]>='0')&&(cal[i]<='9'))||(cal[i]=='.'))//判断当前扫描元素是否为数字或小数点，若是，则入{

while(((cal[i]>='0')&&(cal[i]<='9'))||(cal[i]=='.'))//循环扫描，当是小数时，可以获得完整的小

数字栈

i++;

13

} //主函数 void main() { }

}

}

} i++;

用两种方法实现表达式自动计算

float result=PopStackNum(&sNum);//栈顶就是最终结果，弹出 return result;

float Calculate(char cal[]);//进行Calculate()函数的声明

void ChangeExpression(char expression[],char change[]);//进行ChangeExpression()函数的声明 char expression[MaxSize];//定义一个expression数组，用于存储表达式 char change[MaxSize];//定义change，用于存储后缀表达式 printf(\"Please input a expression:\"); gets(expression); //获取输入的后缀表达式

ChangeExpression(expression,change);//调用表达式转换函数，将表达式转为后缀表达式 printf(\"后缀表达式：%s\\n\

printf(\"计算结果：%f\\n\输出计算结果

2、 下面给出的是用直接计算算法实现的程序的源代码：

#include #include #include #include #define MaxSize 100

//定义两个栈的结构体：数字栈stackNum，符号栈stackSymbol typedef struct stackNum {

int top;

float item[MaxSize];

}stackNum;

typedef struct stackSymbol {

int top;

char entry[MaxSize];

}stackSymbol;

//初始化两个栈：数字栈，符号栈,top赋值为-1 void CreatStackNum(stackNum *s) { }

void CreatStackSymbol(stackSymbol *s)

s->top=-1;

14

{ }

s->top=-1;

用两种方法实现表达式自动计算

//判断栈是否已满：StackNumIsFull(),StackSymbolIsFull() int StackNumIsFull(stackNum *s) { }

int StackSymbolIsFull(stackSymbol *s) { }

//判断栈是否为空：StackNumIsEmpty(),StackSymbolIsEmpty(); int StackNumIsEmpty(stackNum *s) { }

int StackSymbolIsEmpty(stackSymbol *s) {

if(s->top==-1) if(s->top==-1) { } else { }

return 1;

printf(\"\\n The StackNum is Empty\\n\"); return 0;

if(s->top==(MaxSize-1)) { } else { }

return 1;

printf(\"\\n The StackSymbol is Full\\n\"); return 0;

if(s->top==(MaxSize-1)) { } else { }

return 1;

printf(\"The StackNum is Full\\n\"); return 0;

15

}

{ } else { }

return 1;

用两种方法实现表达式自动计算

printf(\"\\n The StackSymbol is Empty\\n\"); return 0;

//压栈函数：PushStackNum(),PushStackSymbol() int PushStackNum(stackNum *s,float item) { }

int PushStackSymbol(stackSymbol *s,char entry) { }

//弹栈函数：PopStackNum(),PopStackSymbol() float PopStackNum(stackNum *s) {

if(!StackNumIsEmpty(s)) { } else

return 0;

if(!StackSymbolIsFull(s)) { } else { }

s->top++;//先将top值加1，在进行压栈 (可以做到以-1为界限) s->entry[s->top]=entry; return 1; return 0; if(!StackNumIsFull(s)) { } else { }

s->top++;//先将top值加1，在进行压栈 (可以做到以-1为界限) s->item[s->top]=item; return 1; return 0;

16

}

char PopStackSymbol(stackSymbol *s) { }

//优先级的函数：StackPre() int StackPre(char entry) { }

if(!StackSymbolIsEmpty(s)) { } else { }

return 0; { }

用两种方法实现表达式自动计算

return s->item[s->top--];//先弹栈，再将top值减一

char c=s->entry[s->top--];//先弹栈，再将top值减一 return c;

switch (entry) //根据不同的字符设置不同的优先级 { case '+': }

return 1; break; return 1; break; return 2; break; return 2; break; return 3; break; return 0;

printf(\"\\n The symbol is Error\\n\"); break;

case '-':

case '*':

case '%':

case '(': //左括号优先级最高

case ')': //右括号优先级最小 default:

//定义优先级的比较函数：StackMatchPre()

17

用两种方法实现表达式自动计算

int StackMatchPre(char entry1,char entry2) { }

//定义根据操作符两两计算的函数：SymbolCal()

float SymbolCal(float popNum1, float popNum2, char popSymbol2) { }

//定义计算表达式的函数：Calculate() float Calculate()

switch(popSymbol2)//根据每个不同字符做不同的操作

{ case '+': }

return popNum1+popNum2; break;

return popNum2-popNum1; break;

return popNum2/popNum1; break;

return popNum1*popNum2; break;

return (int)popNum2%(int)popNum1; break; break;

int pre1=StackPre(entry1); //调用stackPre函数，对操作符做出级别的认定 int pre2=StackPre(entry2);

if((pre1-pre2)>0) //根据差值来确定优先级：1表示entry1优先级高；0表示优先级相同；-1{ }

else if((pre1-pre2)==0) { }

else if((pre1-pre2)<0) { }

return -1;

return 0; return 1;

表示entry2优先级高

case '-':

case '/':

case '*':

case '%':

default : printf(\"Please enter correct symbol;\");

18

{

用两种方法实现表达式自动计算

char expression[MaxSize];//定义获得输入表达式的数组 printf(\"Please input the expression:\"); gets(expression);

stackNum sNum;//定义两个栈，数字栈和符号栈 stackSymbol sSymbol;

CreatStackNum(&sNum);//分别将两个栈进行初始化 CreatStackSymbol(&sSymbol); int i=0;//定义循环变量 int j=0;

char str[MaxSize];//定义临时存储数字的数组 char *st; {

if(((expression[i]>='0')&&(expression[i]<='9'))||(expression[i]=='.'))//当所扫描为数字时，转换为浮点{ } else {

if(sSymbol.top==-1)//当栈为空时，操作符直接进栈 { }

else if(expression[i]=='(')//当操作符为左括号时，直接压栈 { }

else if(expression[i]==')')//当操作符为右括号时，弹出操作符与数字计算，直到栈顶操作符{

while(sSymbol.entry[sSymbol.top]!='(') PushStackSymbol(&sSymbol,expression[i]); PushStackSymbol(&sSymbol,expression[i]);

while((expression[i]>='0')&&(expression[i]<='9')||(expression[i]=='.'))//循环扫描整个数字 (防{ } str[j]='\\0';

st=str;//令指针指向str j=0;

//数字压栈

float atofNum=atof(st);//调用转换函数，将字符型转换为浮点型 PushStackNum(&sNum,atofNum);

str[j]=expression[i]; i++; j++;

//定义指向数组的指针

while(expression[i]!='\\0')//根据'\\0'来扫描整个表达式

型，压栈

止当为小数时被分开扫描)

为左括号，将左括号弹栈

19

算

}

}

{

用两种方法实现表达式自动计算

float popNum1=PopStackNum(&sNum);//弹出数字 float popNum2=PopStackNum(&sNum);

char popSymbol2=PopStackSymbol(&sSymbol);//弹出操作符

float calResult=SymbolCal(popNum1,popNum2,popSymbol2);//调用计算函数，计PushStackNum(&sNum,calResult);//将结果压栈

PopStackSymbol(&sSymbol);//弹出左括号

else if((expression[i]!='(')&&(expression[i]!=')'))//当扫描元素既不是左括号，也不是右括号

{

时，执行优先级比较

}

}

} i++;

}

int lev=StackMatchPre(expression[i],sSymbol.entry[sSymbol.top]);//定义变量，获得优先if(lev==1)//当优先级高时，直接压栈 { }

else if(((lev==0)||(lev==-1))&&(sSymbol.top>=0))//当优先级低或相同时，弹出数字与操{

PushStackSymbol(&sSymbol,expression[i]);

级比较函数的返回值

作符计算

while((StackMatchPre(expression[i],sSymbol.entry[sSymbol.top])!=1)&&(sSymbol.top!=-1))

{ }

PushStackSymbol(&sSymbol,expression[i]);//直到当满足扫描元素优先级高于栈

if(sSymbol.entry[sSymbol.top]=='(')//对栈顶是不是左括号做判断，若是，扫{ }

float popNum1=PopStackNum(&sNum);//弹出两个数字 float popNum2=PopStackNum(&sNum);

char popSymbol2=PopStackSymbol(&sSymbol);//弹出操作符

float calResult=SymbolCal(popNum1,popNum2,popSymbol2);//调用计算函PushStackNum(&sNum,calResult);

//将所得结果压栈

break;

描元素直接入栈。若不是，弹出操作符，弹出操作数，计算，将结果压栈，知道满足条件

数，进行计算

顶元素或栈为空，直接将操作符压栈

20

}

用两种方法实现表达式自动计算

while(sSymbol.top!=-1)//栈顶为空为界，计算剩余数字与操作符 { }

float result=PopStackNum(&sNum);//最终结果即为栈顶元素，将最终的计算结果弹栈 return result;//将结果返回

float popNum1=PopStackNum(&sNum);//弹出两个数字 float popNum2=PopStackNum(&sNum);

char popSymbol2=PopStackSymbol(&sSymbol);//弹出操作符

float calResult=SymbolCal(popNum1,popNum2,popSymbol2);//调用计算函数，计算 PushStackNum(&sNum,calResult);

//将计算结果压栈

//主函数：mian() void main() { }

float Calculate();//对函数声明

float result=Calculate();//调用函数，进行操作 printf(\"%f\输出结果 getchar();//等待输入，将窗口固定

四、 运算结果

图4、中缀转后缀表达式算法运算结果

21

用两种方法实现表达式自动计算

图5、直接运算法运算结果

五、 遇到的问题及解决

这部分我主要遇到了如下几个问题，其内容与解决方案如下所列： ● 中缀转后缀表达式时，部分考虑不周全，具体描述如下：

在扫描表达式时如果遇见小数，应该将小数作为一个整体进行扫描。扫描表达式时直接扫描的话，在下一次进行计算时扫描表达式数字进数组时，无法获得整个的小数。造成计算不准确。所以我在每次扫描时如果扫描元素为操作符则加上一个$符号，所以当遇到小数时，循环扫描则会获取整个小数，再扫描到操作符时加入$符号，就会在数字之间做到加入间隔，让每个数字都作为的一个整体存在。

● 对栈做压栈和弹栈时，没能没清楚前置++和后置++的区别，具体描述如下：

在压栈动作时需要做s->top++，但是将这条语句用在s->entry[s->top++]=entry时则会出错，因为这条语句会先使用s->top,然后在进行s->top++，所以这样会造成s->top=-1时栈并不为空，所以在函数中用sSymbol.top!=-1作为条件进行循环弹出时会造成错误。所以我在上网查了资料以后发现，应该先进行s->top++,在使用s->entry[s->top]=entry进行压栈动作。所以我将s->top++放在了s->entry[s->top]=entry前面，解决了循环条件错误的情况。

六、 心得体会

通过这次作业我对栈有了更深的体会，体会到了栈非常强大的地方。在以后的实践中应该学会良好的运用栈的结构，这样可以令语句结构更加清晰。通过这次作业我也体会到自己的基础知识还不够扎实，比如：前置++和后置++的区别。在学习一门语言时，应该更加注

22

用两种方法实现表达式自动计算

重基础知识，加强基础知识的学习，更应该多实践，多运用，哪怕一个非常小的地方也应该仔细学习，做到真正学习到深处。在编写程序时，应该先有一个程序思想，做到实现程序的具体操作是什么，分好步骤，每个步骤做什么，逻辑结构应该清晰，不然会浪费大量的时间去修改逻辑操作，所以在写程序时应该有这个程序的思想，清晰严谨的逻辑结构。通过这次学习，自己还应该做大量的实践，多实际写程序。只有这样自己才能更好地学习好数据结构这门课程。

23