C语言栈实现中缀表达式转后缀表达式

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

#define MAX_EXPRESSION_LENGTH 100

struct stack_node {
    char c;
    struct stack_node *next;
};

typedef struct stack_node Stack_Node;
typedef struct stack_node *P_Stack_Node;
typedef struct stack_node *Stack;
typedef struct stack_node **P_Stack;

void push_stack(P_Stack, char);

void pop_stack(P_Stack);

P_Stack_Node stack_top(P_Stack);

char *infix_2_suffix(const char *);

int main() {
#if 0
    Stack stack = NULL;
    P_Stack p_stack = &stack;

    push_stack(p_stack, 'a');
    push_stack(p_stack, 'b');
    push_stack(p_stack, 'c');

    P_Stack_Node tmp;
    for (tmp = stack; tmp != NULL; tmp = tmp->next) {
        printf("%c\n", tmp->c);
    }
#endif

    char *input = malloc(sizeof(char) * MAX_EXPRESSION_LENGTH);
    char *i;
    for (i = input; i < input + MAX_EXPRESSION_LENGTH; ++i) {
        *i = '\0';
    }
    char *res = NULL;
    while (scanf("%s", input) == 1) {
#if 0
        printf("%s\n", input);
#endif
        res = infix_2_suffix(input);
        printf("%s\n", res);
        free(res);
        res = NULL;
    }
    free(input);
    return 0;
}

void push_stack(P_Stack p_stack, char c) {
    P_Stack_Node p = malloc(sizeof(Stack_Node));
    p->c = c;
    p->next = NULL;
    if (*p_stack != NULL) p->next = *p_stack;
    *p_stack = p;
}

void pop_stack(P_Stack p_stack) {
    if (*p_stack == NULL) return;
    P_Stack_Node p = *p_stack;
    *p_stack = p->next;
    free(p);
    p = NULL;
}

P_Stack_Node stack_top(P_Stack p_stack) {
    return *p_stack;
}

char *infix_2_suffix(const char *infix) {
    size_t infix_length = strlen(infix);
    char *suffix = malloc(sizeof(char) * (infix_length + 1));
    char *i;
    for (i = suffix; i < suffix + infix_length + 1; ++i) *i = '\0';
    Stack op = NULL;
    P_Stack p_stack = &op;
    const char *j;
    i = suffix;
    for (j = infix; *j != '\0'; ++j) {
        if (isdigit(*j)) *i++ = *j;
        else {
            switch (*j) {
                case '(':
                    push_stack(p_stack, '(');
                    break;
                case ')': {
                    char c;
                    while ((c = stack_top(p_stack)->c) != '(') {
                        *i++ = c;
                        pop_stack(p_stack);
                    }
                    pop_stack(p_stack);
                    break;
                }
                case '+':
                    if (op == NULL) push_stack(p_stack, '+');
                    else {
                        while (1) {
                            if (op == NULL) break;
                            switch (stack_top(p_stack)->c) {
                                case '(':
                                    push_stack(p_stack, '+');
                                    goto label_break;
                                case '+':
                                    *i++ = '+';
                                    pop_stack(p_stack);
                                    push_stack(p_stack, '+');
                                    goto label_break;
                                case '*':
                                    *i++ = '*';
                                    pop_stack(p_stack);
                                    break;
                                default:
                                    break;
                            }
                        }
                    }
                label_break:
                    break;
                case '*':
                    if (op == NULL) push_stack(p_stack, '*');
                    else {
                        while (1) {
                            if (op == NULL) break;
                            switch (stack_top(p_stack)->c) {
                                case '(':
                                case '+':
                                    push_stack(p_stack, '*');
                                    goto label_break_1;
                                case '*':
                                    *i++ = '*';
                                    pop_stack(p_stack);
                                    push_stack(p_stack, '*');
                                    goto label_break_1;
                                default:
                                    break;
                            }
                        }
                    }
                label_break_1:
                    break;
                default:
                    break;
            }
        }
    }
    while (op != NULL) {
        *i++ = stack_top(p_stack)->c;
        pop_stack(p_stack);
    }
    return suffix;
}

运行结果

1+2
12+
1+2
12+
1+2+3
12+3+
1+2+3+4
12+3+4+
1+2+3+4+5+6+7+8+9+0
12+3+4+5+6+7+8+9+0+
1*2
12*
1*2*3
12*3*
1*2*3*4*5*6*7*8*9*0
12*3*4*5*6*7*8*9*0*
1+2*3
123*+
1+2*3+4*5+6*7+8*9
123*+45*+67*+89*+
(1+2)*3*(1+2)
12+3*12+*
((1+2)*2)+(3+4*(5+6))
12+2*3456+*++

缺陷

目前只能输入可带括号的+、*运算符，且操作数必须是个位数的有效表达式。