C语言中缀表达式转化为后缀表达式

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
//别靠空想！！！及其浪费时间！！！多谢谢伪代码分析一下！！！
//后缀表示法计算时候的思路！！！先把元素推到栈中，每碰到一个
char stack[50];
char output[50];
char nouse[50];
int flag=0;
char sz[50];
char laji[50];
int szz[50];
int jieguo[50];
int wuyong[50];
int laji1[50];
int shangpinshu;
//我把提货分成了两种，完全提光的直接删除链表，不完全提光的修改一下就好了
//我在208行的main函数中对输入是否合法进行了检验，附加功能，菜单栏输入是否合法的检验
typedef struct goods //在此定义了链表类型的结构体goods
{
    char goodsname;
    struct goods *next;
} LinkList;

LinkList *creat(int n) //该函数的功能是初始化链表，因为返回值linklist是一个指针所以在creat前面加了个*
{
    LinkList *head, *node, *end;//定义头节点，普通节点，尾部节点；
    head = (LinkList*)malloc(sizeof(LinkList));//分配地址
    end = head;         //若是空链表则头尾节点一样
    for (int i = 0; i < n; i++)
    {
        node = (LinkList*)malloc(sizeof(LinkList));
        scanf("%s", node->goodsname);
        end->next = node;
        end = node;
    }
    end->next = NULL;//结束创建
    return head;
}
//     定义链表插入函数
//    在链表位置第pos节点前插入包含数据val的节点
void InsertList(LinkList *List, int val,int va2,char zi1[],char zi2[] )
{
    int position = 0;
    int pos=2;
    LinkList *P = List;    //    定义节点p指向头节点
    //    寻找pos节点的前驱结点
    while (P != NULL&&position<pos - 1)
    {
        P = P->next;
        ++position;
    }
    LinkList *Tmp = (LinkList*)malloc(sizeof(LinkList));    //    分配一个临时节点用来存储要插入的数据
    if (Tmp == NULL)
    {
        printf("内存分配失败！");
        exit(-1);
    }
    //    插入节点
    strcpy(Tmp->goodsname,zi1);
    Tmp->next = P->next;
    P->next = Tmp;
}




void  WritetoFile(LinkList *head,int n)
{
    FILE *fp;
    int i,flag;
    LinkList *wr;
    wr=head;
    flag=1;
    if((fp = fopen("shop.txt","w"))==NULL)
    {
        printf("写入数据失败了,回家等着下岗吧!\n");
        flag=0;
    }
    if(flag==1)
    {
        fprintf(fp,"%d\t",n);
        for(i = 0; i < n; i++)
        {
            wr=wr->next;
            fprintf(fp,"%c",wr->goodsname);
        }
        fclose(fp);
    }
}
LinkList  *ReadfromFile(LinkList *head,int n)
{
    FILE *fp;
    int i,flag;
    LinkList *wr;
    wr=head;
    flag=1;
    if((fp=fopen("shop.txt","r"))==NULL)
    {
        printf("读取数据失败了,回家等着下岗吧！\n");
        flag=0;
    }
    if(flag==1)
    {
        fprintf(fp,"%d\t",shangpinshu);
        for(i = 0; i < shangpinshu; i++)
        {
            wr=wr->next;
            fprintf(fp,"%c",wr->goodsname);
        }
        fclose(fp);
    }
    return head;

}

  int ce[3]={1,2,-9999};
    int ce1[3]={7,8,-9999};
void push(char stack3[],char push1);
int change(char aa);
void pop(char stack1[],char stack2[])//从第一个栈弹出给第二个,必须堆栈中用东西才可以弹出
{
    int i;
    int j;
    char tmppop;
    for(i=0; i<50; i++)
    {
        if(stack1[i]=='\0')
        {
            tmppop=stack1[0];
            for(j=0; j<i; j++)
            {
                stack1[j]=stack1[j+1];
            }
            break;
        }
    }
    push(stack2,tmppop);
}
void push(char stack3[],char push1)
{
    int i;
    int j;
    for(i=0; i<50; i++)
    {
        if(stack3[i]=='\0')//在函数里用函数里的变量！！！一定注意！！！小心！！！
        {
            if(i==0)
            {
                stack3[0]=push1;
            }
            else
            {
                for(j=0; j<=i; j++)
                {
                    stack3[i-j+1]=stack3[i-j];
                }
                stack3[0]=push1;
                break;
            }
        }
    }
}
void push1(int stack31[],int push11)
{
    int i;
    int j;
    for(i=0; i<50; i++)
    {
        if(stack31[i]<=-9999)//在函数里用函数里的变量！！！一定注意！！！小心！！！
        {
            if(i==0)
            {
                stack31[0]=push11;
            }
            else
            {
                for(j=0; j<=i; j++)
                {
                    stack31[i-j+1]=stack31[i-j];
                }
                stack31[0]=push11;
                break;
            }
        }
    }
}
void pop1(int stack11[],int stack21[])//从第一个栈弹出给第二个,必须堆栈中用东西才可以弹出
{
    int i;
    int j;
    int tmppop1;
    for(i=0; i<50; i++)
    {
        if(stack11[i]<=-9999)
        {
            tmppop1=stack11[0];
            if(i==0)
            {

            }
            else
            {
               for(j=0; j<i; j++)
            {
                stack11[j]=stack11[j+1];
            }
            break;
            }
        }
    }
    push1(stack21,tmppop1);
}
int change(char aa)
{
    int i;
    int j;
    if(aa=='#')
    {
        flag = flag + 1;
    }
    if(flag==0)
    {
        printf("还未遇到#");
    }
    else
    {
        if(flag==1)
        {
            switch (aa)
            {
            case '(':
                printf("压入%c\n",aa);
                push(stack,aa);
                break;
            case ')':
                for(i=0; i<50; i++)
                {
                    if(stack[i]=='(')
                    {
                        for(j=0; j<i; j++)
                        {
                            printf("弹出从算符堆栈到output%c\n",stack[0]);
                            pop(stack,output);

                        }
                        printf("弹出从算符堆栈到nouse%c\n",stack[0]);
                        pop(stack,nouse);
                        break;
                    }
                }
                break;
            case '+':
                if(stack[0]=='\0')
                {
                    printf("压入%c进入算符堆栈\n",aa);
                    push(stack,aa);
                }
                else
                {
                    if(((stack[0]=='*')||(stack[0]=='/'))&&(stack[0]!='('))
                    {
                        printf("弹出从算符堆栈到output%c\n",stack[0]);
                        pop(stack,output);
                        if((stack[0]=='+')||(stack[0]=='-'))
                        {
                            printf("弹出从算符堆栈到output%c\n",stack[0]);
                            pop(stack,output);
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                        else
                        {
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                    }
                    else
                    {
                        if(stack[0]=='(')    //这个位置之前不小心写成了aa，碰到不会的别慌，赶紧用printf检查在哪里附近出了问题与然后细心排查错误！！！
                        {
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                        else
                        {
                            printf("弹出从算符堆栈到output%c\n",stack[0]);
                            pop(stack,output);
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                    }
                }
                break;
            case '-':
                if(stack[0]=='\0')
                {
                    printf("压入%c进入算符堆栈\n",aa);
                    push(stack,aa);
                }
                else
                {
                    if(((stack[0]=='*')||(stack[0]=='/'))&&(stack[0]!='('))
                    {
                        printf("弹出从算符堆栈到output%c\n",stack[0]);
                        pop(stack,output);
                        if((stack[0]=='+')||(stack[0]=='-'))
                        {
                            printf("弹出从算符堆栈到output%c\n",stack[0]);
                            pop(stack,output);
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                        else
                        {
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                    }
                    else
                    {
                        if(stack[0]=='(')
                        {
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                        else
                        {
                            printf("弹出从算符堆栈到output%c\n",stack[0]);
                            pop(stack,output);
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                    }
                }
                break;
            case '*':
                if(stack[0]=='\0')
                {
                    printf("压入%c进入算符堆栈\n",aa);
                    push(stack,aa);
                }
                else
                {
                    if((stack[0]=='+')||(stack[0]=='-')||(stack[0]!='('))
                    {
                        printf("压入%c进入算符堆栈\n",aa);
                        push(stack,aa);
                    }
                    else
                    {
                        if(stack[0]!='(')
                        {
                            printf("弹出从算符堆栈到output%c\n",stack[0]);
                            pop(stack,output);
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                        else
                        {
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                    }
                }
                break;
            case '/':
                if(stack[0]=='\0')
                {
                    printf("压入%c进入算符堆栈\n",aa);
                    push(stack,aa);
                }
                else
                {
                    if((stack[0]=='+')||(stack[0]=='-')||(stack[0]!='('))
                    {
                        printf("压入%c进入算符堆栈\n",aa);
                        push(stack,aa);
                    }
                    else
                    {
                        if(stack[0]!='(')
                        {
                            printf("弹出从算符堆栈到output%c\n",stack[0]);
                            pop(stack,output);
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                        else
                        {
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                    }
                }
                break;
            default:
                if(aa=='#')
                {
                    ;

                }
                else
                {
                    printf("压入%c进入output\n",aa);
                    push(output,aa);
                }
                break;
            }
        }
        else
        {
            flag=flag-2;
            return 2;
        }
    }
}




int main()
{
    int i;
    int j;
    int k;
    int tmp6;
    char zh[50];
    char dz[50];
    char fuhao[50];
    int l;
    int tmpz;
    int zzbsf[50];
    for(i=0; i<50; i++)
    {
        zzbsf[50]='\0';
        stack[i]='\0';
        output[i]='\0';
        zh[i]='\0';
        nouse[i]='\0';
        dz[i]='\0';
        fuhao[i]='e';
        sz[i]='\0';
        szz[i]=-20000;
        jieguo[i]=-20000;
        laji[i]=-20000;
        wuyong[i]=-20000;
    }
    printf("请输入表达式，开始需要输入#\n");
    scanf("%s",zh);
    printf("\n");
    strcpy(zzbsf,zh);
    for(i=0; i<50; i++)
    {
        if(zh[i]=='\0')
        {
            break;
        }
        else
        {
            if(change(zh[i])==2)
            {
                break;
            }
        }
    }
    for(j=0; j<=50; j++)
    {
        if(stack[j]!='\0')
        {
            push(output,stack[j]);
        }
        else
        {
            break;
        }
    }
    pop(output,nouse);
    for(i=0; i<50; i++)
    {
        if(output[i]=='\0')
        {
            output[i-1]='\0';
            break;
        }
    }
    strcpy(dz,output);
    for(i=0; i<50; i++)
    {
        if(output[i]=='\0')
        {
            for(j=0; j<i; j++)
            {
                output[i-j-1]=dz[j];
            }
            break;
        }
    }
    k=0;
    tmp6=0;
    l=-1;
    printf("\n");
    pop(zzbsf,nouse);
    printf("中缀表示法为%s\n",zzbsf);
    printf("\n");
    printf("后缀表示法为%s\n",output);

    getchar();
for(i=0; i<50; i++)
    {
        if(output[i]=='\0')
        {
            break;
        }
        else
        {
            if((output[i]!='+')&&(output[i]!='-')&&(output[i]!='*')&&(output[i]!='/'))
            {
                printf("请输入字符%c对应的数值\n",output[i]);
                scanf("%d",&tmp6);
                getchar();
                szz[i]=tmp6;
            }
            else
            {
                switch (output[i])//switch语句别忘了加大括号！！！
                {
                case '+':
                    szz[i]=80001;
                break;
                case '-':
                    szz[i]=80002;
                break;
                case '*':
                    szz[i]=80003;
                break;
                case '/':
                    szz[i]=80004;
                break;
                default:
                    szz[i]=-30000;
                break;
                }
            }
        }
    }

    for(j=0; j<50; j++)
    {
        if(szz[0]<=-9999)
        {
            break;
        }
        else
        {
            if((szz[0]==80001)||(szz[0]==80002)||(szz[0]==80003)||(szz[0]==80004))
            {
                pop1(szz,wuyong);
                switch (wuyong[0])
                {
                case 80001:
                    printf("弹出+并进行相应计算\n");
                    printf("弹出%d\n",jieguo[0]);
                    printf("弹出%d\n",jieguo[1]);
                    printf("压入%d+%d=%d",jieguo[1],jieguo[0],jieguo[1]+jieguo[0]);
                    pop1(jieguo,wuyong);
                    pop1(jieguo,wuyong);
                    push1(jieguo,(wuyong[0]+wuyong[1]));
                    break;
                case 80002:
                    printf("弹出-并进行相应计算\n");
                    printf("弹出%d\n",jieguo[0]);
                    printf("弹出%d\n",jieguo[1]);
                    printf("压入%d+%d=%d",jieguo[1],jieguo[0],jieguo[1]-jieguo[0]);
                    pop1(jieguo,wuyong);
                    pop1(jieguo,wuyong);
                    push1(jieguo,(wuyong[0]-wuyong[1]));
                    break;
                case 80003:
                    printf("弹出*并进行相应计算\n");
                    printf("弹出%d\n",jieguo[0]);
                    printf("弹出%d\n",jieguo[1]);
                    printf("压入%d+%d=%d",jieguo[1],jieguo[0],jieguo[1]*jieguo[0]);
                    pop1(jieguo,wuyong);
                    pop1(jieguo,wuyong);
                    push1(jieguo,(wuyong[0]*wuyong[1]));
                    break;
                case 80004:
                    printf("弹出/并进行相应计算\n");
                    printf("弹出%d\n",jieguo[0]);
                    printf("弹出%d\n",jieguo[1]);
                    printf("压入%d+%d=%d",jieguo[1],jieguo[0],jieguo[1]/jieguo[0]);
                    pop1(jieguo,wuyong);
                    pop1(jieguo,wuyong);
                    push1(jieguo,(wuyong[0]/wuyong[1]));
                    break;
                }
            }
            else
            {
                printf("压入数字%d\n",szz[0]);
               pop1(szz,jieguo);
            }
        }
    }
    printf("中缀表达式的计算结果为%d\n",jieguo[0]);
    return 0;
}