栈的应用：计算字符串表达式

说明：

1.　通过栈来实现字符串公式的运算；

2.　中缀转后缀：

　　遍历中缀表达式中的数字和符号

　　对于数字：　直接输出

　　对于符号：

　　　　->左括号：　进栈

　　　　->符号：　　与栈顶符号进行优先级比较

　　　　　　　　　栈顶符号的优先级低： 符号进栈

　　　　　　　　　栈顶符号的优先级高： 将栈顶符号弹出并输出,之后进栈

　　　　->右括号：　将栈中的所有符号弹出并输出

3.　计算后缀的值：

　　遍历后缀表达式中的数字和符号

　　对于数字：　进栈

　　对于符号：

　　　　->从栈中弹出右操作数

　　　　->从栈中弹出左操作数

　　　　->根据符号进行运算

　　　　->将运算结果压入栈中

　　遍历结束:栈中的唯一数字为计算结果

4.　这里采用了代码复用的方法，即使用了LinkList链表和LinkStack链栈，详见《LinkList单向链表》和 《LinkStack链栈》；

代码：

main.c

#include <stdio.h>
#include "LinkStack.h"

//输出
void output(char c)
{
if (c != '\0')
{
printf("%c", c);
}
}

//判断是否为数字
int isNumber(char c)
{
return ('0' <= c) && (c <= '9');
}

//判断是否为操作符
int isOperator(char c)
{
return (c == '+') || (c == '-') || (c == '*') || (c == '/');
}

//是否为'('
int isLeft(char c)
{
return (c == '(');
}

//是否为')'
int isRight(char c)
{
return (c == ')');
}

//比较优先级
int priority(char c)
{
int ret = 0;

if ((c == '+') || (c == '-'))
{
ret = 1;
}

if ((c == '*') || (c == '/'))
{
ret = 2;
}

return ret;
}

//字符转数字
int value(char c)
{
return (c - '0');
}

//计算左右操作数的值
int express(int left, int right, char op)
{
int ret = 0;

switch (op)
{
case '+':
ret = left + right;
break;
case '-':
ret = left - right;
break;
case '*':
ret = left * right;
break;
case '/':
ret = left / right;
break;
default:
break;
}

return ret;
}

//中缀转后缀,返回后缀字符串,并输出
char* transform(const char* exp)
{
LinkStack* stack = LinkStack_Create();
char* ret = (char*)malloc(100 * sizeof(char));
memset(ret, '\0', 100 * sizeof(char));
int j = 0;
int i = 0;

while (exp[i] != '\0')
{
int i = 10 * (1 + 5) + 5;
//判断是否为数字
if (isNumber(exp[i]))
{
output(exp[i]);
ret[j++] = exp[i];
}
//判断是否为操作符
else if (isOperator(exp[i]))
{
//遍历栈内符号，如果当前操作符的优先级小于栈顶的操作符，则弹出栈顶，并输出
while (priority(exp[i]) <= priority((char)(int)LinkStack_Top(stack)))
{
output(ret[j++] = (char)(int)LinkStack_Pop(stack));
}
//将当前操作符压入栈
LinkStack_Push(stack, (void*)(int)exp[i]);
}
//判断是否为'('
else if (isLeft(exp[i]))
{
LinkStack_Push(stack, (void*)(int)exp[i]);
}
//判断是否为')'
else if (isRight(exp[i]))
{
char c = '\0';
//遍历栈内元素,弹出非 '(' 的元素
while (!isLeft((char)(int)LinkStack_Top(stack)))
{
output(ret[j++] = (char)(int)LinkStack_Pop(stack));
}
//弹出'('
LinkStack_Pop(stack);
}
else
{
printf("Invalid expression!");
break;
}

i++;
}
//弹出栈内所有元素
while ((LinkStack_Size(stack) > 0) && (exp[i] == '\0'))
{
output(ret[j++] = (char)(int)LinkStack_Pop(stack));
}

LinkStack_Destroy(stack);

return ret;
}

//计算整个表达式的值
int compute(const char* exp)
{
LinkStack* stack = LinkStack_Create();
int ret = 0;
int i = 0;

while (exp[i] != '\0')
{
if (isNumber(exp[i]))
{
LinkStack_Push(stack, (void*)value(exp[i]));
}
else if (isOperator(exp[i]))
{
int right = (int)LinkStack_Pop(stack);
int left = (int)LinkStack_Pop(stack);
int result = express(left, right, exp[i]);

LinkStack_Push(stack, (void*)result);
}
else
{
printf("Invalid expression!");
break;
}

i++;
}

if ((LinkStack_Size(stack) == 1) && (exp[i] == '\0'))
{
ret = (int)LinkStack_Pop(stack);
}
else
{
printf("Invalid expression!");
}

LinkStack_Destroy(stack);

return ret;
}

int main()
{
printf("8 * 2 + 1 - ( 5 - 1 ) / 2 + 2 - 1\n中缀转后缀后结果为：");
char* _strExpression = transform("8*2+1-(5-1)/2+2-1");
printf("\n");
printf("计算结果为：%d ", compute(_strExpression));
printf("\n");

system("pause");

return 0;
}

函数结构分析：

1.isNumber



2.isOperator



3.isLeft



4.isRight



5.priority



6.express



7.transform



8.compute