栈实现计算器

sqstack.cpp

#include <stdlib.h>
#include <stdio.h>

#include "sqstack.h"

sqstack* st_create(void)
{
	sqstack* st;
	st = (sqstack*)malloc(sizeof(*st));
	if (st == NULL)
		return NULL;
	st->top = -1;

	return st;
}

//返回0，为空
//返回1，非空
int st_isempty(sqstack* st)
{
	if (st->top == -1)
		return 0;
	return 1;
}

int st_push(sqstack* st, datatype* data)
{
	if (st->top == MAXSIZE - 1)
		return -1;
	(st->top)++;
	st->data[st->top] = *data;
	return 0;
}

int st_pop(sqstack* st, datatype* data)
{
	if (!st_isempty(st))
		return -1;
	*data = st->data[st->top];
	(st->top)--;
	return 0;
}

int st_top(sqstack* st, datatype* data)
{
	if (!st_isempty(st))
		return -1;
	*data = st->data[st->top];
	return 0;
}

void st_travel(sqstack* st)
{
	while (st->top != -1)
	{
		printf("%d \n", st->data[st->top]);
		(st->top)--;
	}
	printf("\n");
}

void st_destroy(sqstack* st)
{
	free(st);
}

----------------------------------------------------------------------------------------------------------------------------------------------

sqstack.h

#pragma once
#ifndef SQSTACK_H__
#define SQSTACK_H__

#define MAXSIZE 32
typedef int datatype;

typedef struct nod_st
{
	datatype data[MAXSIZE];
	int top;
}sqstack;

sqstack* st_create(void);

int st_isempty(sqstack*);

int st_push(sqstack*, datatype*);

int st_pop(sqstack*, datatype*);

int st_top(sqstack*, datatype*);

void st_travel(sqstack*);

void st_destroy(sqstack*);

#endif

--------------------------------------------------------------------------------------------------------------------------

main.c

#include <stdlib.h>
#include <stdio.h>

#include "sqstack.h"

//计算，并将结果入栈
void compute(sqstack* snum, datatype* op)
{
	//取值
	datatype num1, num2,num;
	st_pop(snum, &num2);
	st_pop(snum, &num1);
	switch (*op)
	{
	case '+':
		num = num1 + num2;
		break;
	case '-':
		num = num1 - num2;
		break;
	case '*':
		num = num1 * num2;
		break;
	case '/':
		num = num1 / num2;
		break;
	default :
		exit(1);
	}
	st_push(snum, &num);


}

//当符号为'）'时，进行括号内的计算
void deal_bracket(sqstack* snum, sqstack* sop)
{
	datatype old_op;
	//获得old_op进行判断，当不为)在进行计算
	old_op = st_top(sop, &old_op);
	while (old_op != '(')
	{
		//出栈符号
		st_pop(sop, &old_op);
		//进行计算
		compute(snum, &old_op);
		//再获取下一个符号进行判断，top只是获取了元素，并没有出栈
		st_top(sop, &old_op);
	}
	//下一个元素为)只进行出栈，不计算
	st_pop(sop, &old_op);
}


int get_pri(int data)
{
	switch (data)
	{
	case '(':
		return 0;
	case '+':
	case '-':
		return 1;
	case '*':
	case '/':
		return 2;
	default :
		return -1;
			
	}
}


//当符号不为)时的操作
void deal_op(sqstack* snum, sqstack* sop,int op)
{
	datatype old_op;
	if (st_isempty(sop) || op == '(')
	{
		st_push(sop, &op);
		return;
	}
	st_top(sop, &old_op);

	//优先级大，直接入栈
	if (get_pri(op) > get_pri(old_op))
	{
		st_push(sop,&op);
		return;
	}
	//优先级小于 等于（入栈的顺序先）,出栈做运算
	while (get_pri(op) <= get_pri(old_op))
	{
		st_pop(sop, &old_op);
		compute(snum, &old_op);
		if (st_isempty(sop))
			break;
		//查询下一个
		st_top(sop, &old_op);
	}
	//压入栈 
	st_push(sop, &old_op);
}


int main(void)
{
	char str[] =  "(11+3)*2-5" ;
	datatype old_op;
	sqstack* snum, * sop;
	int i = 0;
	int flag=0,ret;
	int temp=0;
	snum = st_create();
	if (snum == NULL)
		exit(1);
	sop = st_create();
	if (sop == NULL)
		exit(1);

	while (str[i] != '\0')
	{

		if (str[i] > '0' && str[i] < '9')
		{
			temp = temp * 10 + (str[i] - '0');
			flag = 1;
		}
		else
		{
			if (flag)
			{
				
				st_push(snum, &temp);
				flag = 0;
				temp = 0;
			}

			if (str[i] == ')')
			{

				deal_bracket(snum, sop);

			}
			else
			{
				deal_op(snum, sop,str[i]);
			}

		}


		i++;
	}

	if (flag)
		st_push(snum, &temp);

	while (!st_isempty(sop))
	{
		st_pop(sop, &old_op);
		compute(snum, &old_op);
	}

	st_pop(snum, &temp);
	printf("(11+3)*2-5=%d", temp - '0');

	st_destroy(snum);
	st_destroy(sop);
	exit(0);
}