中缀表达式转后缀表达式（个位数四则运算，C语言）

#include<stdio.h>
#include<stdlib.h>
struct stack{
    char *data;
    int top;
    int maxSize;
};
struct stack *createStack(int maxsize){
    struct stack *s;
    s=(struct stack *)malloc(sizeof(struct stack));
    s->data=(char *)malloc(sizeof(char)*maxsize);
    s->top=-1;
    s->maxSize=maxsize;
    return s;
}
int isFull(struct stack *s){
    return s->top==s->maxSize-1;
}
int isEmpty(struct stack *s){
    return s->top==-1;
}
void push(struct stack *s,char ch){
    if(isFull(s)){
        printf("stack is full\n");
        return;
    }
    s->data[++s->top]=ch;
}
char pop(struct stack *s){
    if(isEmpty(s)){
        printf("stack is empty\n");
        exit(-1);
    }
    return s->data[s->top--];
}
struct queue{
    char *data;
    int front,rear;
    int size;
    int maxsize;
};
struct queue *create(int maxSize){
    struct queue *q;
    q=(struct queue *)malloc(sizeof(struct queue));
    q->data=(char *)malloc(sizeof(char)*maxSize);
    q->front=q->rear=0;
    q->size=0;
    q->maxsize=maxSize;
    return q;
}
void inqueue(struct queue *q,char ch){/*入队*/
    if(q->size==q->maxsize){
        printf("queue is full\n");
        return;
    }
    q->data[q->rear++]=ch;
    if(q->rear==q->maxsize){
        q->rear=0;
    }
    q->size++;
}
char dequeue(struct queue *q){/*出队*/
    if(q->size==0){
        printf("queue is empty\n");
        exit(-1);
    }
    char temp = q->data[q->front++];
    if(q->front==q->maxsize){
        q->front=0;
    }
    q->size--;
    return temp;
}
void PrintQueue(struct queue *q){/*打印队列中所有元素，从队头到队尾*/
    int temp=q->front;
    for(int i=0;i<q->size;i++){
        printf("%c\t",q->data[temp++]);
        temp=temp%q->maxsize;
    }
}
int no_priority(int map[4][4],char ch1,char ch2){
    int i,j;
    switch(ch1){
        case '+':i=0;break;
        case '-':i=1;break;
        case '*':i=2;break;
        case '/':i=3;break;
        default:printf("error.");
    }
    switch(ch2){
        case '+':j=0;break;
        case '-':j=1;break;
        case '*':j=2;break;
        case '/':j=3;break;
        default:printf("error.");
    }
    return map[i][j];
}
int main(){
    int map[4][4]={/*运算符优先关系矩阵*/
    1,1,1,1,
    1,1,1,1,
    0,0,1,1,
    0,0,1,1,
    };
    struct stack *s;
    int n=20;
    s=createStack(n);
    char str[n];
    printf("请输入中缀表达式:");
    scanf("%s",str);
    struct queue *q;
    q=create(n);
    int k=0;
    while(str[k]!='\0'){
        if(str[k]>=48&&str[k]<=57){/*遇到数据直接入队*/
            inqueue(q,str[k]);
        }else if(isEmpty(s)||str[k]=='('){/*如果栈为空或者访问到（直接压栈*/
            push(s,str[k]);
        }else if(str[k]==')'){/*遇到）时弹栈，如果弹出元素不是（，要将弹出元素存入队列，再弹栈，再判断，反复操作*/
            char ch=pop(s);
            while(ch!='('){
                inqueue(q,ch);
                ch=pop(s);
            }
        }else{/*当栈不空，栈顶元素不为（且访问元素优先级小于等于栈顶元素时要不断弹栈并将弹出元素入队，最后将访问元素符号压栈*/
            while(!isEmpty(s)&&s->data[s->top]!='('&&no_priority(map,str[k],s->data[s->top])){
                char ch=pop(s);
                inqueue(q,ch);
            }
            push(s,str[k]);
        }
        k++;
    }
    while(!isEmpty(s)){/*中缀表达式遍历完成后还有部分符号留在栈中，要将他们弹出入队*/
        char ch=pop(s);
        inqueue(q,ch);
    }
    printf("后缀表达式:\n");
    PrintQueue(q);/*输出队列中的后缀表达式*/
    return 0;
}