中缀表达式转换成后缀表达式

例如：

中缀表达式     a+b*c+(d*e+f)*g

转换成后缀表达式，正确答案是;

a b c * + d e * f + g * +

算法分析：

       当读到一个操作数的时候，立即把它放在输出中，如果遇到操作符时，存放在栈中，不立即输出;当遇到左圆括号时我们也要将其推入栈中，我们从一个空栈开始计算；

       如果见到一个右括号，那么就将栈元素弹出，将弹出的符号输出直到我们遇到一个(对应的)左括号，但是这个左括号只被弹出，并不输出 ；

      如果我们见到任何其他的符号( "+", "*", "(" ),那么我们从栈中弹出栈元素直到发现优先级更低的元素为止(也就是弹出比它优先级高的或相等的元素)；有一个例外：除非是在处理一个")"的时候，否则我们绝不从栈中移走"("，对于这种操作，")"的优先级最低，而"("的优先级最高。当从栈弹出元素的工作完成后，我们再将操作符压入栈中。

     最后，如果我们读到输入的末尾，我们将栈元素弹出直到该栈变成空栈，将符号写到输出中。

我写的代码，需要改进，请高人指点。

stack.h

#ifndef STACK_H_
#define STACK_H_

struct StackRecord;
typedef struct StackRecord * STACK;
typedef char ElementType;

struct StackRecord
{
int Capacity;
int TopOfStack;
ElementType * array;
};

int IsEmpty(STACK S);         //判断栈是否为空
int IsFull(STACK S);          //判断栈是否已满
STACK CreateStack(int MaxElements);       //创建空栈
void DisposeStack(STACK S);               //释放栈
void MakeEmpty(STACK S);                  //将栈初始化为空的状态
void Push(ElementType X,STACK S);        //压入栈
ElementType Top(STACK S);                //返回栈顶的数据
void Pop(STACK S);                       //压出栈
ElementType TopAndPop(STACK S);          //返回栈顶的数据并压出栈
int size(char str);                      //返回操作符的优先级大小

#endif

#define EmptyTOS (-1)
#define MinStackSize (5)

stack.c

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

STACK CreateStack(int MaxElements)
{
STACK S;

if(MaxElements<MinStackSize)
{
puts("栈的大小太小");
exit(1);
}

S=(STACK)malloc(sizeof(struct StackRecord));
if(S==NULL)
{
puts("内存不足");
exit(1);
}

S->array=(ElementType *)malloc(sizeof(ElementType)*MaxElements);
if(S->array==NULL)
{
puts("内存不足");
exit(1);
}
S->Capacity=MaxElements;
MakeEmpty(S);

return S;
}

void DisposeStack(STACK S)
{
if(S!=NULL)
{
free(S->array);
free(S);
}
}

int IsEmpty(STACK S)
{
return S->TopOfStack==EmptyTOS;
}

int IsFull(STACK S)
{
return S->TopOfStack==S->Capacity;
}

void MakeEmpty(STACK S)
{
S->TopOfStack=EmptyTOS;
}

void Push(ElementType X,STACK S)
{
if(IsFull(S))
{
puts("栈满了");
exit(1);
}
else
S->array[++S->TopOfStack]=X;
}

ElementType Top(STACK S)
{
if(!IsEmpty(S))
return S->array[S->TopOfStack];
puts("空栈");
return 0;
}

void Pop(STACK S)
{
if(IsEmpty(S))
{
puts("空栈");
exit(1);
}
else
S->TopOfStack--;
}

ElementType TopAndPop(STACK S)
{
if(!IsEmpty(S))
return S->array[S->TopOfStack--];
puts("空栈");
return 0;
}

int size(char str)
{
switch(str)
{
case ')':
return 0;
break;
case '+':
case '-':
return 1;
break;
case '*':
case '/':
return 2;
break;
case '(':
return 3;
break;
}
}

main.c

#include <stdio.h>
#include <string.h>
#include "stack.h"
#define MAXSTACK 100

int main(void)
{
char string1[40];
char string2[40]={0};
int i,j=0;
size_t len;
char a,tmp;
STACK stack;

//创建栈
stack=CreateStack(MAXSTACK);

//获取表达式
printf("输入表达式:\n");
gets(string1);

//计算表达式的字符长度
len=strlen(string1);

//中缀转后缀
for(i=0;i<len;i++)
{
//将数字输出到string2数组中
while(string1[i]>='0' && string1[i]<='9')
{
string2[j++]=string1[i++];
}

//判断是否已超出长度
if(i<len)
{
a=string1[i];
string2[j++]=' ';

//空栈时，压入第一个操作符
if(IsEmpty(stack))
{
Push(a,stack);
}
else if(size(a)>size(Top(stack)))    //如果当前操作符的优先级大于栈顶的操作符就推入栈
Push(a,stack);
else if(Top(stack)=='(')             //如果栈顶操作符是(,就推入当前操作符到栈中
Push(a,stack);
else				     //压出栈中比当前操作符的优先级高的所有操作符，(除当前操作符是)时，特殊处理
{
while(size(a)<=size(Top(stack)))
{
if(Top(stack)=='(' && a==')')    //当栈顶是( 且当前操作符是) 时 压出栈顶 (，不存储在数组string2中
{
Pop(stack);
break;
}
else if(Top(stack)=='(')         //当栈顶是(时，退出当前循环后，压入当前操作符
{
break;
}
else if(a==')')                  //如果当前操作符是),那就把栈中)上面的操作符都压出栈
{
if(size(Top(stack))<3)
{
string2[j++]=TopAndPop(stack);
string2[j++]=' ';
}
else
{
Pop(stack);
break;
}
}
else                            //压出栈中比当前操作符的优先级高的所有操作符
{
string2[j++]=TopAndPop(stack);
string2[j++]=' ';
}
if(IsEmpty(stack))
break;
}
if(a!=')')                            //压入当前操作符到栈中
{
Push(a,stack);
}

}
}

}

while(!IsEmpty(stack))           //如果栈非空，把里面的数据都压出来放在数组string2中
{
string2[j++]=' ';
string2[j++]=TopAndPop(stack);
}
printf("%s\n",string2);

}