栈实现计算器

在表达式中的转换规则

操作数 ：进栈

操作符 : 1）进栈：     空栈 ；优先级高；栈顶是 "（  "同时表达式不是 "  ）"

              2）出栈并计算：表达式符号的优先级不高于栈顶符号 ；表达式为 "  ）" 同时栈顶不为 "（   "； 表达式 " \0 " 同时栈不为空

              3）出栈但不计算：表达式为  "  ）"同时栈顶为 "（  "

头文件

//头文件
#ifndef _STACK_H
#define _STACK_H

#include<stdlib.h>

#define SUCCESS 10000
#define FAILURE 10001
#define TURE    10002
#define FALSE   10003

typedef int ET;
struct Node
{
    ET data;
    struct Node *next;
};
typedef struct Node node;

struct Stack
{
    struct Node *top;
    int count;
};
typedef struct Stack stack;

int stackInit(stack **s);
int stackEmpty(stack *s);
int stackpush(stack **s,ET e);
int Gettop(stack *s);
int pop(stack **s);

#endif

子函数文件

#include"stack.h"

int stackInit(stack **s)
{
    if(NULL == s)
    {
        return FAILURE;
    }
    (*s) = (stack *)malloc(sizeof(stack)*1);
    if(NULL == (*s))
    {
        return FAILURE;
    }
    (*s)->top = NULL;
    (*s)->count = 0;
    return SUCCESS;
}

int stackEmpty(stack *s)
{
    if(s == NULL)
    {
        return FAILURE;
    }

    return (s->top == NULL)? TURE : FALSE;
}

int stackpush(stack **s,ET e)
{
    if(NULL == s || (*s) == NULL)
    {
        return FAILURE;
    }
    node *p = (node *)malloc(sizeof(node)*1);
    if(NULL == p)
    {
        return FAILURE;
    }
    p->data = e;
    p->next =  (*s)->top;
    (*s)->top = p;
    (*s)->count++;
}

int Gettop(stack *s)
{
	if(NULL == s )
    {
        return FAILURE;
    }
	return s->top->data;
}

int e;
int pop(stack **s)
{
	if(NULL == s || (*s) == NULL)
    {
        return FAILURE;
    }
	node *p = (*s)->top;
	ET e = (*s)->top->data;
	(*s)->top = (*s)->top->next;
	(*s)->count--;
	free(p);
	return e;
}

主函数文件

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

int priority(char ch)
{
	switch(ch)
	{
		case '(':
			return 3;
		case '/':
		case '*':
			return 2;
		case '+':
		case '-':
			return 1;
		default :
			return 0;
	}
}
int main()
{
	stack *s_opt,*s_num;
	int i = 0,num1 = 0,num2 = 0,tmp = 0;
	char opt[1024] = {0};
	if(stackInit(&s_opt) != SUCCESS || stackInit(&s_num) != SUCCESS)
	{
		printf("Init Failure!\n");
	}
	printf("Please input : \n");
	scanf("%s",opt);
	
	while( opt[i] != '\0' || stackEmpty(s_opt) != TURE)
	{
		if( opt[i] >= '0' && opt[i] <= '9')
		{
			tmp = tmp * 10 + opt[i] - '0';
			i++;
			
			if(opt[i] > '9' || opt[i] < '0') 
			{
				stackpush(&s_num,tmp);
				tmp = 0;
			}
		}
		else
		{
			if(opt[i] == ')' && Gettop(s_opt) == '(')
			{
				pop(&s_opt);
				i++;
				continue;
			}
			if( stackEmpty(s_opt) == TURE || ( priority(opt[i]) > priority(Gettop(s_opt)) ) 
				|| ( Gettop(s_opt) == '(' && opt[i] != ')' ) )
			{
				stackpush(&s_opt,opt[i]);
				i++;
				continue;
			}
			if( (opt[i] == '\0' && stackEmpty(s_opt) != TURE) ||
				(opt[i] == ')' && Gettop(s_opt) != '(' ) ||
				(priority(opt[i]) <= priority(Gettop(s_opt)) ) )
			{
				switch(pop(&s_opt))
				{
					case '+':
						num1 = pop(&s_num);
						num2 = pop(&s_num);
						stackpush(&s_num,(num2+num1));
						break;
					case '-':
						num1 = pop(&s_num);
						num2 = pop(&s_num);
						stackpush(&s_num,(num2 - num1));
						break;
					case '*':
						num1 = pop(&s_num);
						num2 = pop(&s_num);
						stackpush(&s_num,(num2 * num1));
						break;
					case '/':
						num1 = pop(&s_num);
						num2 = pop(&s_num);
						stackpush(&s_num,(num2 / num1));
						break;
					default :
						break;
				}
			}
		}	
	}
	printf("%d\n",Gettop(s_num));
	return 0;
}