C语言多位数中、后缀表达式实现代码

 最近搞了一下简易计算器的实现方法，学习了下中、后缀表达式的实现方法。技术有限、如有bug敬请指正！

// Copyright 2023 dchen


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

#define MAXSIZE 100

// 栈
typedef struct {
    int16_t data[MAXSIZE];
    int16_t top;
} Stack_t;


void initStack(Stack_t *s) { s->top = -1; }

bool isEmpty(Stack_t *s) { return s->top == -1; }

bool isFull(Stack_t *s) { return s->top == MAXSIZE - 1; }

bool push(Stack_t *s, int16_t x) {
    if (isFull(s)) return false;
    s->data[++(s->top)] = x;
    return true;
}

bool pop(Stack_t *s, int16_t *x) {
    if (isEmpty(s)) return false;
    *x = s->data[(s->top)--];
    return true;
}

bool getTop(Stack_t *s, int16_t *x) {
    if (isEmpty(s)) return false;
    *x = s->data[s->top];
    return true;
}

// 判断运算符的优先级
int16_t priority(char op) {
    int16_t Priority = 0;
    switch (op)  {
        case '+':
        case '-':
            Priority = 1;
            break;
        case '*':
        case '/':
            Priority = 2;
            break;
        default:
            Priority = 0;
            break;
    }
    return Priority;
}

/*
 * 实现中缀表达式转换为后缀表达式的函数,如遇多位数则以空格隔开
 * infix: :     待转的中缀表达式
 * postfix:     转换后的后缀表达式
*/
bool infixToPostfix(char *infix, char *postfix) {
    Stack_t s;                          // 定义栈
    initStack(&s);                      // 初始化栈
    int16_t i = 0, j = 0;
    int16_t flag = 0;
//    push(&s, '(');
//   strcat(infix, ")");
    while (infix[i] != '\0') {
        char c = infix[i];
        if (c == '(') {
            push(&s, c);
        } else if (isdigit(c)) {                       // 如果为数字
            char c1 = infix[i+1];
            while (isdigit(c1)) {               // 下一个字符仍为数字，则为多位数，执行多位数处理程序
                if (flag == 0) {                // 首次
                    flag = 1;
                    postfix[j++] = ' ';         // 添加空格符并写入栈中
                    postfix[j++] = c;           // 将数据写入栈中
                } else {
                    postfix[j++] = c;           // 将数据写入栈中
                }
                i++;
                c = c1;                         // 将下一个数值写入变量c中暂存
                c1 = infix[i+1];                // 获取新的数值，用于while轮询判断
            }
            if (flag == 1) {                    // 大于10
                flag = 0;
                postfix[j++] = c;               // 将数据写入栈中
                postfix[j++] = ' ';             // 添加空格符并写入栈中
                c = c1;
                i++;
                continue;                       // 处理完成多位数，直接结束本次循环
            }
            postfix[j++] = c;                   // 单数字，直接将数据写入栈中
        } else if (c == ')') {
            int16_t x;
            while (getTop(&s, &x) && x != '(') {
                pop(&s, &x);
                postfix[j++] = x;
            }
            if (!isEmpty(&s) && getTop(&s, &x) && x == '(') {
                pop(&s, &x);
            } else {
                return false;
            }
        } else if (c == '+' || c == '-' || c == '*' || c == '/') {
            int16_t x;
            while (getTop(&s, &x) && priority(x) >= priority(c)) {
                pop(&s, &x);
                postfix[j++] = x;
            }
            push(&s, c);
        } else {
            return false;
        }
        i++;
    }
    while (!isEmpty(&s)) {
        int16_t x;
        pop(&s, &x);
        postfix[j++] = x;
    }
    postfix[j] = '\0';
    return true;
}

// 实现计算后缀表达式的函数：
int16_t calculatePostfix(char *postfix) {
    Stack_t s;                                  // 定义栈
    initStack(&s);                              // 初始化栈

    int16_t i = 0;
    while (postfix[i] != '\0') {
        char c = postfix[i];
        if (isdigit(c)) {                       // 数字
            push(&s, c - '0');
        } else if (c == ' ') {                  // 空格
            int16_t num = 0;
            i++;
            c = postfix[i];
            while (c != ' ') {
                num = num * 10 + (postfix[i]-'0');
                i++;
                c = postfix[i];
            }
            push(&s, num);
        } else if (c == '+' || c == '-' || c == '*' || c == '/') {
            int16_t x, y;
            if (!pop(&s, &y) || !pop(&s, &x)) return false;
            switch (c) {
                case '+':
                    push(&s, x + y);
                    break;
                case '-':
                    push(&s, x - y);
                    break;
                case '*':
                    push(&s, x * y);
                    break;
                case '/':
                    push(&s, x / y);
                    break;
            }
        } else {
            return false;
        }
        i++;
    }

    int16_t result;
    pop(&s, &result);
    if (!isEmpty(&s)) return false;
    return result;
}


int main(void) {
    char pdata[100] = "100+(40+2*3)";
    char *str  = pdata;
    char data[1000];
    char *str1 = data;
    infixToPostfix(str, str1);
    int16_t num = calculatePostfix(str1);
    printf("\r\ninfix:%s\r\n", str);
    printf("==============================\r\n");
    printf("Postfix:%s\r\n", str1);
    printf("%s= %d\r\n", str, num);

    system("pause");
    return 0;
}

 输出结果：

infix:100+(40+2*3)
==============================
Postfix: 100  40 23*++
100+(40+2*3)= 146
请按任意键继续. . .