【数据结构】用栈实现的简单计算器（先转换为后缀表达式、可以计算带括号的）

先将中缀表达式转化成后缀表达式

再计算后缀表达式

计算后缀表达式的规则：从左到右遍历表达式的每个数字和符号，遇到是数字就进栈，遇到是符号，就将处于栈顶的两个数字出栈，进行运算，运算结果进栈，一直到最终获得结果。

代码 C++：VS2013 + WIN7

#include <iostream>
using namespace std;

#define ok 0
#define error -1

typedef int Elemtype;
typedef int status;//函数返回的状态，如ok error

typedef struct StackNode
{
Elemtype data;
struct StackNode *next;
}StackNode, *StackNodeP;

typedef struct LinkStack
{
StackNodeP top;
int count;
}LinkStack;

LinkStack* LinkStack_Create();//链栈的创建
status LinkStack_Clear(LinkStack* stack);//链栈的清空
int LinkStack_Isempty(LinkStack* stack);//链栈是否为空
status LinkStack_Push(LinkStack* stack, Elemtype e);//链栈的入栈
Elemtype LinkStack_Pop(LinkStack* stack);//链栈的出栈
int LinkStack_Length(LinkStack* stack);//链栈的长度
Elemtype LinkStack_Top(LinkStack* stack);//链栈的头部元素

status change(char* buf, char* afterbuf)
{
int i = 0;
LinkStack* LS = LinkStack_Create();
/*
设定
( -1
+ 1
- 2
* 3
/ 4
*/
while (*buf)
{
if ((*buf >= '0') && (*buf <= '9'))
{
while ((*buf >= '0') && (*buf <= '9'))
{
afterbuf[i] = *buf;
buf++;
i++;
}
afterbuf[i++] = ',';
}
if (*buf == '+')
{
if (LinkStack_Isempty(LS))//如果链栈为空，则直接将‘+’入栈
LinkStack_Push(LS, 1);
else if (LinkStack_Top(LS)> 2)//如果链栈的头结点上为‘*’‘/’，则栈中所有都弹出
{
while (!LinkStack_Isempty(LS))//直到将栈中的所有都弹出
{
if (LinkStack_Top(LS) == -1)//如果为'（'则停止循环
{
break;
}
else
{
switch (LinkStack_Top(LS))
{
case 1:
afterbuf[i++] = '+'; afterbuf[i++] = ','; break;
case 2:
afterbuf[i++] = '-'; afterbuf[i++] = ','; break;
case 3:
afterbuf[i++] = '*'; afterbuf[i++] = ','; break;
case 4:
afterbuf[i++] = '/'; afterbuf[i++] = ','; break;
}
}
LinkStack_Pop(LS);
}
LinkStack_Push(LS, 1);
}
else//如果链栈中也是‘+’‘-’则直接入栈
LinkStack_Push(LS, 1);
buf++;
}
if (*buf == '-')
{
if (LinkStack_Isempty(LS))//如果链栈为空，则直接将‘+’入栈
LinkStack_Push(LS, 2);
else if (LinkStack_Top(LS)> 2)//如果链栈的头结点上为‘*’‘/’，则栈中所有都弹出
{
while (!LinkStack_Isempty(LS))//直到将栈中的所有都弹出
{
if (LinkStack_Top(LS) == -1)//如果为'（'则停止循环
{
break;
}
else
{
switch (LinkStack_Top(LS))
{
case 1:
afterbuf[i++] = '+'; afterbuf[i++] = ','; break;
case 2:
afterbuf[i++] = '-'; afterbuf[i++] = ','; break;
case 3:
afterbuf[i++] = '*'; afterbuf[i++] = ','; break;
case 4:
afterbuf[i++] = '/'; afterbuf[i++] = ','; break;
}
}
LinkStack_Pop(LS);
}
LinkStack_Push(LS, 2);
}
else//如果链栈中也是‘+’‘-’则直接入栈
LinkStack_Push(LS, 2);
buf++;
}
if (*buf == '*')//如果为'*'直接入栈
{
LinkStack_Push(LS, 3);
buf++;
}
if (*buf == '/')//如果为'/'直接入栈
{
LinkStack_Push(LS, 4);
buf++;
}
if (*buf == '(')//如果为左括号则直接进栈
{
LinkStack_Push(LS, -1);
buf++;
}
if (*buf == ')')//如果为右括号则出栈直到左括号
{
while (LinkStack_Top(LS) != -1)
{
switch (LinkStack_Top(LS))
{
case 1:
afterbuf[i++] = '+'; afterbuf[i++] = ','; break;
case 2:
afterbuf[i++] = '-'; afterbuf[i++] = ','; break;
case 3:
afterbuf[i++] = '*'; afterbuf[i++] = ','; break;
case 4:
afterbuf[i++] = '/'; afterbuf[i++] = ','; break;
}
LinkStack_Pop(LS);
}
LinkStack_Pop(LS);//最后把左括号给弹出来
buf++;
}
}
while (!LinkStack_Isempty(LS))
{
switch (LinkStack_Top(LS))
{
case 1:
afterbuf[i++] = '+'; afterbuf[i++] = ','; break;
case 2:
afterbuf[i++] = '-'; afterbuf[i++] = ','; break;
case 3:
afterbuf[i++] = '*'; afterbuf[i++] = ','; break;
case 4:
afterbuf[i++] = '/'; afterbuf[i++] = ','; break;
}
LinkStack_Pop(LS);
b2f9
}
return NULL;
}

int calculate(char* array)
{
int result = 0;//用来保存计算结果
int a, b;
char buf[10] = { 0 };
int i = 0;
LinkStack* LS = LinkStack_Create();//创建一个栈
while (*array)
{
if ((*array >= '0') && (*array <= '9'))
{
while ((*array >= '0') && (*array <= '9'))//检测多少位数
{
buf[i] = *array;
i++;
array++;
}
LinkStack_Push(LS, atoi(buf));//将数字入栈
memset(buf, 0, sizeof(buf));
i = 0;
}
if (*array == '+')
{
a = LinkStack_Pop(LS);//取出栈顶元素
b = LinkStack_Pop(LS);//取出栈顶元素
result = b + a;
LinkStack_Push(LS, result);//再将计算结果入栈
}
if (*array == '-')
{
a = LinkStack_Pop(LS);
b = LinkStack_Pop(LS);
result = b - a;
LinkStack_Push(LS, result);
}
if (*array == '*')
{
a = LinkStack_Pop(LS);
b = LinkStack_Pop(LS);
result = b * a;
LinkStack_Push(LS, result);
}
if (*array == '/')
{
a = LinkStack_Pop(LS);
b = LinkStack_Pop(LS);
result = b / a;
LinkStack_Push(LS, result);
}
array++;
}
return result;
}

int main(void)
{
char* buf = (char*)malloc(sizeof(char));
char afterbuf[1024] = { 0 };
cin >> buf;
change(buf, afterbuf);//中缀表达式转后缀表达式
cout << "转换的后缀表达式为：" << afterbuf << endl;
int result = calculate(afterbuf);//用后缀表达式来计算
cout << "计算结果为：" << result << endl;
system("pause");
}

//链栈的创建
LinkStack* LinkStack_Create()
{
LinkStack* temp = NULL;
temp = (LinkStack*)malloc(sizeof(LinkStack));
if (temp == NULL)
cout << "LinkStack_create 出错" << endl;
temp->count = 0;
temp->top = NULL;
return temp;
}
//链栈的清空
status LinkStack_Clear(LinkStack* stack)
{
if (stack == NULL)
return ok;
stack->top->next = NULL;
stack->count = 0;
return ok;
}
//链栈是否为空
int LinkStack_Isempty(LinkStack* stack)
{
if (stack == NULL)
return error;
return stack->top == NULL ? 1 : 0;
}

//链栈的长度
int LinkStack_Length(LinkStack* stack)
{
if (stack == NULL)
return error;
return stack->count;
}
//链栈的入栈
status LinkStack_Push(LinkStack* stack, Elemtype e)
{
if (stack == NULL)
return error;
LinkStack* temp = NULL;
temp = (LinkStack*)stack;

StackNodeP SNP = (StackNodeP)malloc(sizeof(StackNode));
SNP->data = e;
SNP->next = temp->top;
temp->top = SNP;

temp->count++;
return ok;
}
//链栈的出栈
Elemtype LinkStack_Pop(LinkStack* stack)
{
if (stack == NULL)
return error;
LinkStack* temp = NULL;
temp = (LinkStack*)stack;
Elemtype node = temp->top->data;//这是将要删除的元素缓存下来
StackNodeP p = temp->top;//将栈顶结点赋值给p
temp->top = temp->top->next;//栈顶指针下移一位，指向后一个结点
free(p);//释放结点

temp->count--;
return node;
}
//链栈的头部元素
Elemtype LinkStack_Top(LinkStack* stack)
{
if (stack == NULL)
return error;

return stack->top->data;
}



执行结果图：