栈的操作和c语言实现算术表达式求值

</pre><p><span style="font-size:18px;">栈是一种特殊的线性表，按照“后进先出”的原则处理数据。</span></p><p><span style="font-size:18px;">栈的基本操作有两种：一种是入栈（Push），即把数据保存到栈顶，注意在入栈前应该先检查栈是否已满，如满则不能入栈操作，未满则修改栈顶指针，使其向上移动一个元素的位置，然后将数据保存到栈顶指针所指的位置。 一种是出栈（Pop），即把栈顶数据弹出，注意在出栈之前检查栈是否为空，如果栈为空没有数据则提示不能进行出栈操作，若不空，则修改栈顶指针，使其指向栈中的下一个元素。</span></p><p><span style="font-size:18px;">1.编写操作栈的头文件  </span></p><p><pre name="code" class="cpp">typedef struct stack
{
DATA data[SIZE+1];   //数据元素  top为o表示栈为空
int top;   //定义栈顶

} seqStack;

其中DATA定义栈中元素的数据类型，SIZE表示栈的最大容量，SIZE+1表示栈的数据从下标为1开始，当top为0时，表示栈为空。

2.初始化栈

seqStack *seqStackInit()
{
seqStack *p;
if(p=(seqStack *)malloc(sizeof(seqStack)))  //申请内存
{
p->top=0;
return p;
}
return NULL;  //申请内存失败
}

初始化栈需要做两件事，首先按照SIZE指定的大小申请一片内存空间，保存栈中数据，然后设置栈顶指针的值为0，表示空栈。

3.判断栈的状态

int seqStackIsempty(seqStack *s)  //栈是否为空
{
return(s->top==0);
}

int seqStackIsfull(seqStack *s)  //栈是否满
{
return(s->top==SIZE);
}

对栈操作前先判断栈的状态，入栈前栈是否满，出栈前栈是否为空。

4.清空栈 释放栈所占的内存空间

void seqStackClear(seqStack *s)
{
s->top=0;   //清空栈
}

void seqStackfree(seqStack *s)  //释放栈的空间
{
if(s)
free(s);

}

清空栈时，即把栈顶指针top置0，释放栈时，因为栈是用malloc函数分配的，所以不使用时用free函数释放分配的内存空间。

5.入栈操作

int seqStackPush(seqStack *s,DATA data)
{
if((s->top+1)>SIZE)       //栈的上一个位置超过最大位置
{
printf("栈溢出\n");
return 0;
}
s->data[++s->top]=data;   //修改栈顶指针，把元素入栈
return 1;
}

入栈时，判断若top已经满了（s->top==size），则top+1就超出栈的最大内存空间，提示栈溢出，做出错处理。若没有溢出，则栈顶指针向上移动一位，把数据放入其中，即入栈。

6.出栈操作

int seqStackPop(seqStack *s)     //出栈
{
if(s->top==0)
{
printf("栈为空:\n");
exit(0);
}
return (s->data[s->top--]);  //从栈顶弹出元素
}

出栈与入栈相反，从栈顶弹出一个数据元素。先判断top是否为0，若为0，则表示空栈，提示出错，若不为0，修改栈顶指针减一，即往下移动一位，返回此时栈顶指针所指位置，原来栈顶元素弹出，即出栈。

7.获取栈顶元素

DATA seqStackPeek(seqStack *s)  //读出栈顶元素
{
if(s->top==0)
{
printf("栈为空");
exit(0);
}
return (s->data[s->top]); //返回栈顶元素
}

在出栈操作中，是把原来的栈顶元素弹出（抛弃了），即出栈后栈顶元素就不存在了，若只是读取一下栈顶的元素而不删除，就不需要将top指针往下移动，不修改指针位置，这样返回栈顶后栈顶数据元素还在。

以上为栈的基本操作，下面举一个实用例子深入理解栈的相关操作。

栈的实际运用：算术表达式求值

在计算机中输入一个算式如：（2+3）*5 容易知道先计算2+3=5，再将5*5=25，，但计算机在读入算式时的具体过程是怎样的？

计算机先逐步扫描：先是（括号，这时不知道右括号在哪里出现，所以先保存起来，然后是2，也不知道该字符下一位是什么，也先保存，然后是+，这时知道是加上一个数，但不知道加什么，先保存起来，然后是3，这时知道是2+3，直接相加吗？不能，如果3后面是*，或者/的高优先级话就先计算，所以也先保存，然后是），这时括号内的2+3就可以取出运算了，得出结果5后再保存起来（由此可以看出加减的优先级大于（）的优先级），然后是*，保存起来，然后是5，保存起来，然后是=号，表示整个算式结束了，将2+3得到的5与5相乘，输出最终结果。

由上分析可知，程序需要保存操作数，保存运算符（+，-，*，/，=，(，)），还需要确定优先级（乘除大于加减，加减大于括号，括号可以改变优先级的顺序，相同优先级从左往右计算）。

为了简化程序，只考虑加减乘除四则运算。

首先调用库函数：

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define SIZE 50
typedef int DATA;  //定义栈元素类型
#include "biaodashi.h"

第六行引用最开始的栈的基本操作程序为头文件，

具体函数模块分析：

1.每次读取检查字符是否为运算符

int isOperator(char c)    //检查字符是否为运算符
{
switch(c)
{
case '+':
case '-':
case '*':
case '/':
case '(':
case ')':
case '=':
return 1;
break;
default:
return 0;
break;       //字符c是运算符则返回1，，否则返回0
}
}

定义isOperator函数，如果字符为+，-，*，/，（，），=，运算符，则返回1，否则返回0,。

2.比较运算符的优先级:

注：在计算表达式时，为了方便判断增设“=”为表达式定界符，即以=表示开始，=表示结束

int PRI(char oper1,char oper2)     //判断两个运算符的优先级
//如果oper1>oper2返回1    如果oper1<oper2返回-1   如果oper1,,oper2是左右符号返回0

{
int pri;
switch(oper2)   //判断优先级
{
case '+':
case '-':
if(oper1=='('||oper1=='=')  //为左括号
pri=-1;        //oper1<oper2
else
pri=1;       //oper1>oper2
break;
case '*':
case '/':
if(oper1=='*'||oper1=='/'||oper1==')')
pri=1;   //oper1>oper2
else
pri=-1;     //oper1<oper2
break;
case '(':
if(oper1==')')       //右括号右侧不能马上出现左括号
{
printf("语法错误\n");
exit(0);
} else
pri=-1;       //oper1<oper2
break;
case ')':
if(oper1=='(')
pri=0;
else if(oper1=='=')
{
printf("括号不匹配\n");
exit(0);
}else
pri=1;
break;
case '=':
if(oper1=='(')
{
printf("括号不匹配\n");
exit(0);
}else if(oper1=='=')
pri=0;  //等号匹配，返回0
else
pri=1;      //oper1>oper2
break;
}
return pri;
}

在该函数中对oper1和oper2两个运算符比较，34到40行表示：oper2为+或-号，若oper1为（或=号，oper1<oper2，则pri=-1，否则oper1>oper2,pri=1。41到47行同理。48到55行表示：oper2等于（时，若oper1等于），即）（，这样右括号后直接左括号是不对的，oper2等于（，若oper1不为），则oper1<oper2，pri=1。56到65表示：oper2等于），若oper1等于（，则括号匹配，pri等于0，如果oper1等于=，即：=），括号不匹配。第66到75行表示：oper2为=号，若oper1为（，即：（=，括号不匹配，如果oper1等于=，表示结束算式，如果oper1为其他，则oper1>oper2，pri=1。
最后返回pri。

3.对于优先级高的运算符，需要将运算符两侧的数据进行计算，

int Calc(int a,int oper,int b)  //计算两个操作数的结果
{
switch(oper)     //根据运算符计算
{
case '+':return a+b;

case '-':return a-b;

case '*':return a*b;

case '/':
if(b!=0)
return a/b;
else
{
printf("除数不能为0!\n");
exit(0);
}
}

}

当为除数时，注意考虑除数不能为0，
4.写好以上函数部分，就可以开始计算表达式的值：

int CalcExp(char exp[])   //表达式计算函数
{

seqStack *StackOper,*StackData;   //指向两个栈的指针变量，一个操作符，一个运算数
int i=0,flag=0;   //flag作为标志，用来处理多位数
DATA a,b,c,q,x,t,oper;
StackOper=seqStackInit();
StackData=seqStackInit();    //初始化两个栈

q=0;  //变量q保存多位数的操作
x='=';
seqStackPush(StackOper,x);  //首先把等号=进入操作栈
x=seqStackPeek(StackOper); //获取操作栈的首元素
c=exp[i++];
while(c!='='||x!='=')  //循环处理表达式中的每一个字符
{
if(isOperator(c))  //如果是运算符
{
if(flag){
seqStackPush(StackData,q);  //表达式入栈
q=0;   //操作数清零
flag=0;   //标志清零，表示操作数已经入栈
}
switch(PRI(x,c))   //判断运算符优先级
{
case -1:
seqStackPush(StackOper,c);  //运算符进栈
c=exp[i++];
break;
case 0:
c=seqStackPop(StackOper);  //运算符括号，等号出栈，被抛弃
c=exp[i++];   //取下一个 字符
break;
case 1:
oper=seqStackPop(StackOper);   //运算符出栈
b=seqStackPop(StackData);
a=seqStackPop(StackData);  //两个操作数出栈
t=Calc(a,oper,b);  //计算结果
seqStackPush(StackData,t);  //将运算结果入栈
break;

}
}else if(c>='0'&&c<='9')  //如果输出的字符在0到9之间
{
c-='0';   //把字符转换成数字
q=q*10+c;       //多位数的进位处理

c=exp[i++];  //取出下一位字符
flag=1;  //设置标志，表示操作数未入栈
}
else {
printf("输入错误\n");
getch();
exit(0);
}
x=seqStackPeek(StackOper);  //获取栈顶操作符
}
q=seqStackPop(StackData);
seqStackfree(StackOper);
seqStackfree(StackData);  //释放内存占用空间
return q;  //出栈，返回结果

}

该部分注解：

首先是以一个字符串exp为参数，返回一个整型数（即表达式的结果）,一个标志变量flag，作用是处理当操作数是多位数时处理多位数的情况（代码一次只能从表达式中获取一个字符），当操作数是多位数就把每一位获取后再入栈。flag为0表示没有操作数入栈，为1表示有操作数需要入栈。

然后将变量x为“=”，将该符号作为表达式的第一个运算符入栈，然后循环诸葛处理表达式字符串中的每一个字符，直到遇到表达式的结束字符“=”为止。

5.主函数

int main()
{
int c;
char exp[80];
printf("请输入需要计算的表达式(以=结束):\n");
scanf("%s",exp);
printf("%s%d\n",exp,CalcExp(exp));
getch();
return 0;
}

最后编译结果：