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

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

typedef struct SNode *Stack;

struct SNode
{
    char op=NULL;//运算符
    Stack Next;
};

typedef struct LNode *List;

struct LNode
{    
    int tag;
    union
    {
        int num;//运算数
        char op=NULL;
    }bit;
    List Next;
};

//空堆栈
Stack Empty()
{
    Stack head=(Stack)malloc(sizeof(SNode));
    head->Next=NULL;
    return head;
}

//建立空表
List MakeEmpty()
{
    List head;
    head=(List)malloc(sizeof(LNode));
    head->Next=NULL;
    return head;
}

int main ()
{
    Stack stack;
    stack=Empty();
    Stack first=stack;
    Stack s=stack;
    Stack p=stack;
    
    List list;
    list=MakeEmpty();
    List rear=list;
    
    char ch;
    char Bit[100];
    int cnt=0;
    while((ch=getchar())!=EOF&&ch!='\n')
    {
        Bit[cnt]=ch;
        cnt++;
    }

    for(int i=0;i<cnt;i++)
    {
        if(Bit[i]>='0'&&Bit[i]<='9')
        {
            List node=(List)malloc(sizeof(LNode));
            node->tag=1;
            if(rear->tag==1)
                rear->bit.num=rear->bit.num*10+(Bit[i]-'0');
            else
            {
                node->bit.num=Bit[i]-'0';
                rear->Next=node;
                rear=rear->Next;
            }        
        }
        else if(Bit[i]=='(')
        {
            Stack snode=(Stack)malloc(sizeof(SNode));
            snode->op=Bit[i];
            snode->Next=first->Next;
            first->Next=snode;
            s=stack->Next;
        }
        else if(Bit[i]==')')
        {
            for(Stack j=s;s;j=s)
            {
                if(j->op!='(')
                {
                    List node=(List)malloc(sizeof(LNode));
                    node->tag=0;
                    node->bit.op=j->op;
                    rear->Next=node;
                    rear=rear->Next;
                    first->Next=s->Next;
                    s=s->Next;
                    free(j);            
                }
                else
                {
                    first->Next=j->Next;
                    s=s->Next;
                    free(j);           
                    break;
                }
            }
            if(s==NULL)
                s=stack;    
        }
        else
        {
            if(Bit[i]=='*'||Bit[i]=='/')
            {
                if(s==stack||s->op=='+'||s->op=='-'||s->op=='(')
                {
                    Stack snode=(Stack)malloc(sizeof(SNode));
                    snode->op=Bit[i];
                    snode->Next=first->Next;
                    first->Next=snode;
                    s=stack->Next;
                }
                else if(s->op=='*'||s->op=='/')
                {
                    List node=(List)malloc(sizeof(LNode));
                    node->tag=0;
                    node->bit.op=s->op;
                    rear->Next=node;
                    rear=rear->Next;
                    s->op=Bit[i];
                }
            }
            else if(Bit[i]=='+'||Bit[i]=='-')
            {
                if(s==stack||s->op=='(')
                {
                    Stack snode=(Stack)malloc(sizeof(SNode));
                    snode->op=Bit[i];
                    snode->Next=first->Next;
                    first->Next=snode;
                    s=stack->Next;
                }
                else
                {
                    for(Stack t=s;t;t=s)
                    {
                        if(t->op!='(')
                        {
                            List node=(List)malloc(sizeof(LNode));
                            node->tag=0;
                            node->bit.op=t->op;
                             rear->Next=node;
                            rear=rear->Next;
                            first->Next=t->Next;
                            s=s->Next;
                            free(t);
                            
                        }
                        else
                        {
                            Stack snode=(Stack)malloc(sizeof(SNode));
                            snode->op=Bit[i];
                            snode->Next=first->Next;
                            first->Next=snode;
                            s=stack->Next;
                            break;
                         }    
                    }
                    while(s==NULL)
                    {
                        Stack snode=(Stack)malloc(sizeof(SNode));
                        snode->op=Bit[i];
                        snode->Next=first->Next;
                        first->Next=snode;
                        s=stack->Next;
                    }
                }
            }
        }
    }
    
    for(Stack del=first->Next;del;del=first->Next)
    {
        List node=(List)malloc(sizeof(LNode));
        node->tag=0;
        node->bit.op=del->op;
        rear->Next=node;
        rear=rear->Next;
        first->Next=del->Next;
        free(del);
    }
    for(List i=list;i!=rear->Next;i=i->Next)
    {
        if(i->tag==1)
        {
            printf("%d",i->bit.num);
        }
        else if(i->tag==0)
        {
            printf("%c",i->bit.op);
        }
    }
    return 0;
}