无括号算术表达式处理算法

#include"stdio.h"
#include"stdlib.h"

#define TRUE 1
#define FALSE 0
#define Stack_Size 50

/*顺序栈-整型*/
typedef struct
{
	int elem[Stack_Size];
	int  top;
} nStack;


void  nInitStack(nStack *S)
{
	S->top=-1;
}


int nIsEmpty(nStack *S)
{
	return(S->top==-1?TRUE:FALSE);
}


int nIsFull(nStack *S)
{
	return(S->top==Stack_Size-1?TRUE:FALSE);
}

int nPush(nStack * S, int x)
{
	if(S->top== Stack_Size-1)  return(FALSE);
	S->top++;
	S->elem[S->top]=x;
	return(TRUE);
}

int nPop(nStack * S, int *x)
{
	if(S->top==-1)
		return(FALSE);
	else
	{
		*x= S->elem[S->top];
		S->top--;
		return(TRUE);
	}
}

int nGetTop(nStack *S, int *x)
{
	/* 将栈S的栈顶元素弹出，放到x所指的存储空间中，但栈顶指针保持不变 */
	if(S->top==-1)  /*栈为空*/
		return(FALSE);
	else
	{
		*x = S->elem[S->top];
		return(TRUE);
	}
}


typedef struct
{
	char elem[Stack_Size];
	int  top;
} strStack;


void strInitStack(strStack *S)
{
	S->top=-1;
}


int strIsEmpty(strStack *S)
{
	return(S->top==-1?TRUE:FALSE);
}

/*判栈满*/
int strIsFull(strStack *S)  	/*判断栈S为满栈时返回值为真，反之为假*/
{
	return(S->top==Stack_Size-1?TRUE:FALSE);
}

char strPush(strStack * S, char x)
{
	if(S->top== Stack_Size-1)  return(FALSE);  /*栈已满*/
	S->top++;
	S->elem[S->top]=x;
	return(TRUE);
}

char strPop(strStack * S, char *x)
{
	/* 将栈S的栈顶元素弹出，放到x所指的存储空间中 */
	if(S->top==-1)  /*栈为空*/
		return(FALSE);
	else
	{
		*x= S->elem[S->top];
		S->top--;    /* 修改栈顶指针 */
		return(TRUE);
	}
}

int strGetTop(strStack *S, char *x)
{
	/* 将栈S的栈顶元素弹出，放到x所指的存储空间中，但栈顶指针保持不变 */
	if(S->top==-1)  /*栈为空*/
		return(FALSE);
	else
	{
		*x = S->elem[S->top];
		return(TRUE);
	}
}

/*功能函数*/
int Match(char ch,char str)
{
	if(ch=='('&&str==')')
	{
		return TRUE;
	}
	else if(ch=='['&&str==']')
	{
		return TRUE;
	}
	else if(ch=='{'&&str=='}')
	{
		return TRUE;
	}
	else return FALSE;
}

int In(char ch)
{
	if(ch=='+')
	{
		return TRUE;
	}
	else if(ch=='-')
	{
		return TRUE;
	}
	else if(ch=='*')
	{
		return TRUE;
	}
	else if(ch=='/')
	{
		return TRUE;
	}
	else if(ch=='(')
	{
		return TRUE;
	}
	else if(ch==')')
	{
		return TRUE;
	}
	else if(ch=='#')
	{
		return TRUE;
	}
	else return FALSE;
}

char Compare(char x,char ch)
{
	switch(x)
	{
		case '+':
			if(ch=='+'||ch=='-'||ch==')'||ch=='#')
				return '>';
			else if(ch=='*'||ch=='/'||ch=='(')
				return '<';
			break;
		case '-':
			if(ch=='+'||ch=='-'||ch==')'||ch=='#')
				return '>';
			else if(ch=='*'||ch=='/'||ch=='(')
				return '<';
			break;
		case '*':
			if(ch=='(')
			{
				return '<';
			}
			else
			{
				return '>';
			}
			break;
		case '/':
			if(ch=='(')
				return '<';
			else
				return '>';
			break;
		case '(':
			if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='(')
				return '<';
			else if(ch==')')
				return '=';
			else if(ch=='#')
				return '0';
			break;
		case ')':
			if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch==')'||ch=='#')
				return '>';
			else if(ch=='(')
				return '0';
			break;
		case '#':
			if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='(')
				return '<';
			else if(ch=='#')
				return '=';
			else if(ch==')')
				return '0';
			break;
		default:
			return '0';
			break;
	}

}

int Execute(int a,char op,int b)
{
	switch(op)
	{
		case '+':
			return (a+b);
			break;
		case '-':
			return (a-b);
			break;
		case '*':
			return (a*b);
			break;
		case '/':
			return (a/b);
			break;
	}
}
int ExpEvaluation()   /*operatsign  运算符栈 operatdata运算数栈，OPS为运算符集合*/
{
	char x,y,ch;
	char op;
	int a,b,v;

	nStack operatdata;
	strStack operatsign;
	nInitStack(&operatdata); //初始化栈
	strInitStack(&operatsign);
	strPush(&operatsign,'#'); //#结束符号压入栈

	printf("\nPlease input an expression (Ending with #) :\n");
	ch=getchar();


//	strGetTop(&operatsign,&y);

	while(ch!='#'||y!='#')   /* 接受到字符无结束符 继续接受 */
	{
		if(!In(ch))                   /*是运算数*/
		{

			int temp; 		   /*存放数字的临时变量*/
			temp=ch-'0';     	/*将字符转换为十进制数*/
			fflush(stdin);   //清空缓存
			ch=getchar();
			nPush(&operatdata,temp);
		}
		else
			switch(Compare(y,ch))
			{
				case '<':
					strPush(&operatsign,ch);
					fflush(stdin);
					ch=getchar();
					break;
				case '=':
					strPop(&operatsign,&x);
					fflush(stdin);
					ch=getchar();
					break;
				case '>':
					strPop(&operatsign,&op);
					nPop(&operatdata,&b);
					nPop(&operatdata,&a);
					v=Execute(a,op,b);  /* 对a和b进行op运算 */
					nPush(&operatdata,v);
					break;
			}
		strGetTop(&operatsign,&y);

	}
	nGetTop(&operatdata,&v);
	return (v);
}

int main()
{
	int result;
	result=ExpEvaluation();
	printf("\n%d",result);

	return 0;
}