数据结构之简单表达式计算器(读入中缀转后缀，通过后缀计算结果)

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

typedef struct Node					//中缀转后缀表达式使用的结点
{
char str;
struct Node * pNext;
}NODE,* PNODE;

typedef struct iNode				//后缀表达式使用的结点
{
double val;
struct iNode * pNext;
}INODE,* PINODE;

typedef struct stack				//中缀转后缀表达式使用的栈
{
PNODE pBase;
PNODE pTop;
}STACK,* PSTACK;

typedef struct istack				//后缀表达式使用的栈
{
PINODE pBase;
PINODE pTop;
}ISTACK,* PISTACK;

//以下为中缀转后缀表达式使用的函数
void init(PSTACK);
void push(PSTACK,char);
bool pop(PSTACK,char *);
bool empty(PSTACK);
void traverse(PSTACK);

//以下为后缀表达式使用的函数
void initi(PSTACK);
void pushi(PSTACK,double);
bool popi(PSTACK,double *);
bool emptyi(PSTACK);
void traversei(PSTACK);

char * midtolast();		//读入中缀表达式转后缀表达式使用的函数
void result(char*);		//用后缀表达式计算结果

int main()
{
char * pstr;
pstr= midtolast();
strcat(pstr,"#");
result(pstr);
return 0;
}

void init(PSTACK pStack)
{
pStack->pBase=pStack->pTop=(PNODE)malloc(sizeof(NODE));
pStack->pBase->pNext=NULL;
}

void push(PSTACK pStack,char str)
{
PNODE pNew=(PNODE)malloc(sizeof(NODE));
pNew->pNext=pStack->pTop;
pNew->str=str;
pStack->pTop=pNew;
}

bool pop(PSTACK pStack,char * pstr)
{
if (pStack->pTop==pStack->pBase)
return false;
*pstr=pStack->pTop->str;
PNODE pTemp=pStack->pTop;
pStack->pTop=pStack->pTop->pNext;
free(pTemp);
return true;
}

bool empty(PSTACK pStack )
{
if (pStack->pTop==pStack->pBase)
return true;
return false;
}

void traverse(PSTACK pStack)
{
PNODE p=pStack->pTop;
while(p!=pStack->pBase)
{
printf("%c ",p->str);
p=p->pNext;
}
printf("\n");
}

void initi(PISTACK pStack)
{
pStack->pBase=pStack->pTop=(PINODE)malloc(sizeof(INODE));
pStack->pBase->pNext=NULL;
}

void pushi(PISTACK pStack,double val)
{
PINODE pNew=(PINODE)malloc(sizeof(INODE));
pNew->pNext=pStack->pTop;
pNew->val=val;
pStack->pTop=pNew;
}

bool popi(PISTACK pStack,double * pVal)
{
if (pStack->pTop==pStack->pBase)
return false;
*pVal=pStack->pTop->val;
PINODE pTemp=pStack->pTop;
pStack->pTop=pStack->pTop->pNext;
free(pTemp);
return true;
}

bool emptyi(PISTACK pStack )
{
if (pStack->pTop==pStack->pBase)
return true;
return false;
}

void traversei(PISTACK pStack)
{
PINODE p=pStack->pTop;
while(p!=pStack->pBase)
{
printf("%f ",p->val);
p=p->pNext;
}
printf("\n");
}

char * midtolast()
{
char ch,str,str1[50];
STACK s;
init(&s);

printf("请输入算式，用#号结束：");
scanf("%c",&ch);

int i=0;
while('#'!=ch)
{
while( ch>='0' && ch<='9')
{
str1[i++]=ch;
//printf("%c",ch);
scanf("%c",&ch);
if (ch<'0' || ch>'9')
{
str1[i++]=' ';
//printf(" ");
break;
}
}

if(')'==ch)
{
pop(&s,&str);
while('('!=str)
{
str1[i++]=str;
str1[i++]=' ';
//printf("%c ",str);
pop(&s,&str);
}
}
else if	( '+'== ch || '-' == ch )
{
if( empty(&s) )
{
push(&s,ch);
}
else
{
do
{
pop(&s,&str);
if ('('==str)
{
push(&s,str);
break;
}
str1[i++]=str;
str1[i++]=' ';
//printf("%c ",str);
} while (!empty(&s));
push(&s,ch);
}
}
else if ( '*'== ch || '/' == ch )
{
if( empty(&s) )
{
push(&s,ch);
}
else
{
pop(&s,&str);
if ('('==str || '+'== str || '-' == str )
{
push(&s,str);
push(&s,ch);
}
else
{
str1[i++]=str;
str1[i++]=' ';
//printf("%c ",str);
push(&s,ch);
}
}
}
else if ( '#'== ch)
{
break;
}
else
{
push(&s,ch);
}
scanf("%c",&ch);
}

while(!empty(&s))
{
pop(&s,&str);
str1[i++]=str;
str1[i++]=' ';
//printf("%c ",str);
}
//printf("\n");
str1[i++]='\0';
printf("后缀表达式：%s\n",str1);
char * pstr=(char*)malloc(50);
strcpy(pstr,str1);
return pstr;
}

void result(char* pstr)
{
double d,e;
ISTACK s;
int i=0,j=0;
char str[50];
char ch=pstr[j++];

while(ch!='#')
{
while( isdigit(ch) || ch=='.')
{
str[i++]=ch;
str[i]='\0';
ch=pstr[j++];
if (ch==' ' || ch=='+' || ch=='-' || ch=='*' || ch=='/' || ch=='#' )
{
d=atof(str);
pushi(&s,d);
i=0;
break;
}
}

switch(ch)
{
case '+':
popi(&s,&d);
popi(&s,&e);
pushi(&s,e+d);
break;
case '-':
popi(&s,&d);
popi(&s,&e);
pushi(&s,e-d);
break;
case '*':
popi(&s,&d);
popi(&s,&e);
pushi(&s,e*d);
break;
case '/':
popi(&s,&d);
popi(&s,&e);
if (d!=0)
{
pushi(&s,e/d);
}
else
{
printf("除零错误!!!\n");
return ;
}

break;
}
ch=pstr[j++];
}

printf("计算结果：");
traversei(&s);
}