顺序栈实现算术运算。

声明本文非原创
#include <stdio.h>
#include <stdlib.h>

#define MAX 64

typedef struct
{
int data[MAX];
int top;
} sqstack;

void setnull(sqstack *s)//置空
{
s->top = -1;
}

int empty_stack(sqstack *s)//判断是否空
{
return ( s->top == -1 );
}

int push_stack(sqstack *s, int value)//入栈
{
if ( s->top == (MAX - 1) )
{
printf("Overflow!/n");
return -1;
}

s->top++;
s->data[s->top] = value;

return 0;
}

int pop_stack(sqstack *s)//出栈
{
if ( empty_stack(s) )
{
printf("Underflow!/n");
return -1;
}
s->top--;

return s->data[s->top+1];
}

int top_stack(sqstack *s)
{
if ( empty_stack(s) )
{
printf("Empty stack!/n");
return -1;
}

return s->data[s->top];
}

int convert_operator(char c)
{
switch ( c )
{
case '+' :
case '-' :
return 1;
case '*' :
case '/' :
return 2;
case '(' :
return 3;
}
}

void deal_tmp(sqstack *operator, sqstack *operand, char ch)
{
int op1, op2;

while ( convert_operator(ch) <= convert_operator((char)top_stack(operator)) )
{
op2 = pop_stack(operand);
op1 = pop_stack(operand);
switch ( (char)pop_stack(operator) )
{
case '+' :
printf("push data: %d + %d/n", op1, op2);
push_stack(operand, op1 + op2);
break;
case '-' :
printf("push data: %d - %d/n", op1, op2);
push_stack(operand, op1 - op2);
break;
case '*' :
printf("push data: %d * %d/n", op1, op2);
push_stack(operand, op1 * op2);
break;
case '/' :
printf("push data: %d / %d/n", op1, op2);
push_stack(operand, op1 / op2);
break;
}
if ( empty_stack(operator) || ((char)pop_stack(operator) == '(') )
{
break;
}
}
push_stack(operator, (int)ch);
}

void deal_bracket(sqstack *operator, sqstack *operand)
{
int op1, op2;

while ( (char)top_stack(operator) != '(' )
{
op2 = pop_stack(operand);
op1 = pop_stack(operand);
switch ( (char)pop_stack(operator) )
{
case '+' :
printf("push data: %d + %d/n", op1, op2);
push_stack(operand, op1 + op2);
break;
case '-' :
printf("push data: %d - %d/n", op1, op2);
push_stack(operand, op1 - op2);
break;
case '*' :
printf("push data: %d * %d/n", op1, op2);
push_stack(operand, op1 * op2);
break;
case '/' :
printf("push data: %d / %d/n", op1, op2);
push_stack(operand, op1 / op2);
break;
}
}
pop_stack(operator);
}

/*********************************************/
int main()
{
char expression[30],*p;
sqstack *operator, *operand;
int sum, flag = 0;
int op1, op2;

operator = (sqstack *)malloc(sizeof(sqstack));
setnull(operator);
operand = (sqstack *)malloc(sizeof(sqstack));
setnull(operand);

gets(expression);
p = expression;

while ( *p )
{
if ( (*p >= '0') && (*p <= '9') )
{
p++;
continue;
}
switch ( *p )
{
case '+' :
case '-' :
case '*' :
case '/' :
case ' ' :
case '(' :
case ')' :
break;
default :
printf("Wrong Character %c in expression!/n", *p);
return -1;
}
p++;
}

p = expression;
while ( *p )
{
if ( (*p >= '0') && (*p <= '9') )
{
if ( flag )
{
sum = 10*sum + (*p - '0');
}
else
{
sum = *p - '0';
flag = 1;
}
p++;
continue;
}

if ( flag )
{
printf("push data %d/n", sum);
push_stack(operand, sum);
flag = 0;
}

if ( *p == ' ' )
{
p++;
continue;
}

if ( empty_stack( operator ) )
{
printf("push %c/n", *p);
push_stack(operator, (int)*p);
p++;
continue;
}

if ( *p == ')' )
{
printf("*** Wow, we meet ) ***/n");
deal_bracket(operator, operand);
p++;
continue;
}

if ( (convert_operator(*p) > convert_operator((char)top_stack(operator))) || ((char)top_stack(operator) == '(') )
{
printf("push %c/n", *p);
push_stack(operator, (int)*p);
}
else
{
deal_tmp(operator, operand, *p);
}
p++;
}
if ( flag ) push_stack(operand, sum);

while ( !empty_stack(operator) )
{
op2 = pop_stack(operand);
op1 = pop_stack(operand);

switch ( (char)pop_stack(operator) )
{
case '+' :
printf("push data: %d + %d/n", op1, op2);
push_stack(operand, op1 + op2);
break;
case '-' :
printf("push data: %d - %d/n", op1, op2);
push_stack(operand, op1 - op2);
case '*' :
printf("push data: %d * %d/n", op1, op2);
push_stack(operand, op1 * op2);
break;
case '/' :
printf("push data: %d / %d/n", op1, op2);
push_stack(operand, op1 / op2);
break;
}
}

printf("%d/n", pop_stack(operand));

return 0;
}