【C语言】运用栈解决四则运算

输入一串整数算式（包含加、减、乘、除四则运算和括号运算），以#结尾，计算并输出算式结果。

输入样例：

(10/2/5+1)*2#

输出样例:

4

 代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//节点结构体
typedef struct node {
   int data;//储存数据
   struct node *next;//指向下一个节点
}Node;

//栈结构体
typedef struct stack {
    int count;//位数
    Node *top;//指向top节点
}Stack;

//创建栈结构体
Stack *_createStack();
//创建节点结构体
Node *_createNode();
//出栈
int _pop(Stack **s);
//进栈
void _push(Stack **s,int a);
//判空
int _emptyStack(Stack *S);
//获取非空栈顶元素
int _getTop(Stack *S);
//优先级判断
int _priority(char ch);
//运算
void _operation(Stack *s1, Stack *s2);
//销毁
void _destroy(Stack *S);

int main()
{
    //创建两个栈，一个用于数字，一个用于操作符
    Stack *S1, *S2;
    S1 = _createStack();
    S2 = _createStack();

    //输入计算式
    char str[100] = {0};
    scanf("%s", str);
    int i;
    int iCarry = 0;//进位
    i = 0;
    //计算:当计算式未读取完或着操作符还在被压栈进行while循环
    while(str[i] != '#' || _emptyStack(S2) == 0) {
        //数字
        if(str[i] >= '0' && str[i] <= '9') {

            iCarry = iCarry * 10 + str[i] - '0';
            i++;
            if(str[i] < '0' || str[i] > '9') {//数字一直相加直到下一个为操作符
                _push(&S1,iCarry);
                iCarry = 0;
            }
        }

        else {
            //进栈不运算:空栈、栈顶为'('且该操作符不为')'、该操作符优先级高于栈顶
            if((_emptyStack(S2) == 1) || (_getTop(S2) == '(' && str[i] != ')') || (_priority(str[i]) > _priority(_getTop(S2)))){
                _push(&S2,str[i]);
                i++;
                continue;
            }
            //出栈不运算:运算结束()里的内容，将'('出栈
            if(_getTop(S2) == '(' && str[i] == ')') {
                _pop(&S2);
                i++;
                continue;
            }
            //出栈运算:栈不为空，')'前有其他操作符、该操作符优先级小于等于压栈的栈顶操作符
            if((_emptyStack(S2) == 0) || (str[i] == ')' && _getTop(S2) != '(') || _priority(str[i]) <= _priority(_getTop(S2))) {
               _operation(S1,S2);
               }
            continue;
        }
    }
    //打印结果
    printf("%d",_getTop(S1));
    //销毁
    _destroy(S1);
    _destroy(S2);
    return 0;
}
//_createStack
Stack *_createStack() {
    Stack *p;
    p = (Stack*)malloc(sizeof(Stack));
    p -> count = 0; //初始化栈
    p -> top = NULL;
    return p;
}
//_createNode
Node *_createNode() {
    Node *p;
    p = (Node*)malloc(sizeof(Node));
    return p;
}
//_emptyStack
int _emptyStack(Stack *S){
    return (S -> count == 0) ? 1 : 0;
}
//_getTop
int _getTop(Stack *S) {
    if(S == NULL)
        return 0;
    else
        return (S -> top -> data);
}
//_priority
int _priority(char ch) {
    switch(ch)
	{
		case '(':				//前括号优先级3
			return 3;
		case '*':
		case '/':				//乘除2
			return 2;
		case '+':
		case '-':				//加减1
			return 1;
		default :
			return 0;
	}
}
//_pop
int _pop(Stack **s){
	if (NULL == (*s) -> top)
		return 0;
    int a;
    a = (*s) -> top -> data;
    (*s) -> top = (*s) -> top -> next;
    (*s) -> count--;
printf("pop%d\n",a);
	return a;
}
//_push
void _push(Stack **s,int a) {
    Node *p = (Node*)malloc(sizeof(Node));
    p -> data = a;
    p -> next = (*s) -> top;
    (*s) -> top = p;
    (*s) -> count++;
printf("push%d\n",a);
}
//_operation
void _operation(Stack *s1, Stack *s2){
    int tmp,t;
    switch(_pop(&s2)) {
    case '+':
        _push(&s1,_pop(&s1) + _pop(&s1));
        break;
    case '-':
        tmp= _pop(&s1);
        _push(&s1,_pop(&s1) - tmp);
        break;
    case '*':
        _push(&s1,_pop(&s1) * _pop(&s1));
        break;
    case '/':
        t = _pop(&s1);
        _push(&s1, _pop(&s1) / t);
        break;
    default :
        break;
    }
}
void _destroy(Stack *S) {
    Node *p;
    p = S -> top;
    while(p) {
        S -> top = S -> top -> next;
        free(p);
        p = S -> top;
    }
}