混合运算器（1位数）

#include "stdafx.h"
#include<stdio.h>
#include<stdlib.h>
#define INIT_SIZE 100
#define ADD_SIZE 10


typedef struct{
	char elem;
	int  elem1;
}SElemType;
typedef struct{
	SElemType *top;
	SElemType *base;
	int size;
}Stack;


void init_Stack(Stack &S);//栈初始化
SElemType getTop(Stack S);//获取栈顶元素
void push(Stack &S,SElemType e);//进栈
void pop(Stack &S,SElemType &e);//出栈
int stackEmpty(Stack S);//判断栈是否为空
int evaluateExpression(char *exp);//计算后缀表达式式的值
int operate(int a,char theta,int b);//从char栈中取数字运算
int isChar(char c);//判断字符是否为运算符
char precede(char a,char b);//判断运算符优先级
void change(char *ptr,char *result);//将中缀式转化为后缀式
void print(char *S);//打印字符串


int _tmain(int argc, _TCHAR* argv[])
{
	int i;
	char p,origin[50],result[50];
	printf("请输入中缀表达式并以#结尾：");
	scanf("%c",&origin[0]);
	for(i=1;origin[i-1]!='#'&&i<50;i++)
	{
		scanf("%c",&origin[i]);
	}
	print(origin);
	printf("\n");
	change(origin,result);
	print(result);
	printf("\n");
	printf("%d",evaluateExpression(result));
	system("pause");
	return 0;
}
void init_Stack(Stack &S)
{
	S.base=S.top=(SElemType *)malloc(INIT_SIZE*sizeof(SElemType));
	if(!S.base)
	{
		printf("内存分配错误");
		exit(0);
	}
	S.size=INIT_SIZE;
}
void push(Stack &S,SElemType e)
{
	if(S.top-S.base>=S.size)
	{
		S.base=(SElemType *)realloc(S.base,(ADD_SIZE+S.size)*sizeof(SElemType));
		if(!S.base)
		{
			printf("内存分配错误");
			exit(0);
		}
		S.top=S.base+S.size;
		S.size+=ADD_SIZE;
	}
	*S.top++=e;
}
void pop(Stack &S,SElemType &e)
{
	if(S.base==S.top)
	{
		printf("栈为空");
		exit(0);
	}
	e=*--S.top;
}
SElemType getTop(Stack S)
{
	return *(S.top-1);
}
int stackEmpty(Stack S)
{
	if(S.base==S.top)
		return 1;
	else
		return 0;
}
int evaluateExpression(char *exp)
{
	Stack S;
	int sum;
	SElemType e1,e2,temp;
	init_Stack(S);
	do
	{
		if(!isChar(*exp))//数字进栈
		{
			temp.elem1=*exp-'0';
			push(S,temp);
		}
		else//运算符，弹出两数字，运算后入栈
		{
			pop(S,e1);
			pop(S,e2);
			sum=operate(e2.elem1,*exp,e1.elem1);
			temp.elem1=sum;
			push(S,temp);
		}
		exp++;
	}while(*exp!='\0');
	pop(S,e1);
	sum=e1.elem1;
	return sum;
}
int operate(int a,char theta,int b)
{
	int a1,b1;
	a1=a;
	b1=b;
	switch(theta)
	{
	case'+':return a1+b1;
	case'-':return a1-b1;
	case'*':return a1*b1;
	case'/':if(b1!=0) 
				return a1/b1;
			else
				return 0;
	default:return 0;
	}
}
int isChar(char c)
{
	if(c>='0'&&c<='9')
		return 0;
	else
		return 1;
}
char precede(char a,char b)
{
	if(a=='+'||a=='-')
	{
		if(b=='*'||b=='/'||b=='(')
			return '<';
		else
			return '>';
	}
	else if(a=='*'||a=='/')
	{
		return '>';
	}
	else if(a=='(')
	{
			if(b==')')
				return '=';
			else
				return '<';
	}
	else if(a==')')
	{
		return '>';
	}
	else if(a=='#')
	{
		if(b=='#')
			return '=';
		else
			return '<';
	}
}
void change(char *ptr,char *result)
{
	Stack S;
	SElemType e,temp; 
	init_Stack(S);
	temp.elem='#';
	push(S,temp);
	while(*ptr!='#')
	{
		if(!isChar(*ptr))//数字直接复制
		{
			//printf("%c",*ptr);
			*result++=*ptr;
		}
		else
		{
			if(*ptr=='(')
			{
				temp.elem=*ptr;
				push(S,temp);
			}
			else if(*ptr==')')
				do
				{
					pop(S,e);
					if(e.elem!='(')
						*result++=e.elem;
				}while(e.elem!='(');
			else
			{
				switch(precede(getTop(S).elem,*ptr))
				{
				case'<':
					temp.elem=*ptr;
					push(S,temp);
				case'=':
					break;
				case'>':
					pop(S,e);
					*result++=e.elem;
					temp.elem=*ptr;
					push(S,temp);
				}
			}
		}
		ptr++;
	}
	while(!stackEmpty(S))
	{
		pop(S,e);
		if(e.elem!='#')
			*result++=e.elem;
	}
	*result='\0';
}
void print(char *S)
{
	char *p;
	p=S;
	while(*p!='\0'&&*p!='#')
	{
		printf("%c",*p);
		p++;
	}
}