1、 用C程序实现波兰符号法。 实现功能：输入波兰符号法公式，求出公式类型 输入：波兰符号法的数学计算公式或命题公式 输出：输出公式类型。 输入公式的符号说明： 序号 联结词 程序替代符号 1 ¬ ! 2 ∧ & 3 ∨ | 4 → - 5 ↔ = 6 () () 例如：¬(P ∧ Q) → (¬P ∨ ¬Q) 输入：-!&PQ|!P!Q 输出：重言式

以下是实现波兰符号法的C程序，可以输入波兰符号法的数学计算公式或命题公式，输出公式类型（重言式、矛盾式或普通命题）：

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

#define MAX_STACK_SIZE 100    // 栈的最大容量

typedef enum {
    False = 0,
    True = 1
} Boolean;

typedef struct {
    int top;
    char data[MAX_STACK_SIZE];
} Stack;

// 初始化栈
void init(Stack *s) {
    s->top = -1;
}

// 判断栈是否为空
Boolean isEmpty(Stack *s) {
    return s->top == -1 ? True : False;
}

// 判断栈是否已满
Boolean isFull(Stack *s) {
    return s->top == MAX_STACK_SIZE - 1 ? True : False;
}

// 入栈操作
void push(Stack *s, char c) {
    if (isFull(s)) {
        printf("栈已满，无法入栈！\n");
        return;
    }
    s->data[++s->top] = c;
}

// 出栈操作
char pop(Stack *s) {
    if (isEmpty(s)) {
        printf("栈已空，无法出栈！\n");
        exit(1);
    }
    return s->data[s->top--];
}

// 获取栈顶元素（不出栈）
char peek(Stack *s) {
    if (isEmpty(s)) {
        printf("栈已空，无法获取栈顶元素！\n");
        exit(1);
    }
    return s->data[s->top];
}

// 判断字符是否是运算符
Boolean isOperator(char c) {
    return c == '!' || c == '&' || c == '|' || c == '-' || c == '=';
}

// 判断字符是哪个运算符
int getOperator(char c) {
    if (c == '!') {
        return 1;
    }
    if (c == '&') {
        return 2;
    }
    if (c == '|') {
        return 3;
    }
    if (c == '-') {
        return 4;
    }
    if (c == '=') {
        return 5;
    }
    return 0;
}

// 判断命题公式是否为重言式或矛盾式
Boolean isTautology(char *pf) {
    Stack s;
    init(&s);
    int i;
    for (i = 0; pf[i] != '\0'; i++) {
        if (isalpha(pf[i])) {    // 如果是命题符号，直接入栈
            push(&s, pf[i]);
        } else if (isOperator(pf[i])) {    // 如果是运算符，弹出栈顶元素进行运算
            char c1, c2;
            int op = getOperator(pf[i]);
            switch (op) {
                case 1:    // 非运算符
                    c1 = pop(&s);
                    push(&s, c1 == 'F' ? 'T' : 'F');
                    break;
                case 2:    // 与运算符
                    c1 = pop(&s);
                    c2 = pop(&s);
                    push(&s, (c1 == 'T' && c2 == 'T') ? 'T' : 'F');
                    break;
                case 3:    // 或运算符
                    c1 = pop(&s);
                    c2 = pop(&s);
                    push(&s, (c1 == 'T' || c2 == 'T') ? 'T' : 'F');
                    break;
                case 4:    // 蕴含运算符
                    c1 = pop(&s);
                    c2 = pop(&s);
                    push(&s, (c2 == 'F' || c1 == 'T') ? 'T' : 'F');
                    break;
                case 5:    // 等价运算符
                    c1 = pop(&s);
                    c2 = pop(&s);
                    push(&s, (c1 == c2) ? 'T' : 'F');
                    break;
                default:
                    break;
            }
        }
    }
    char result = pop(&s);
    if (result == 'T') {
        return True;
    } else {
        return False;
    }
}

int main() {
    char pf[100];
    printf("请输入波兰符号法公式：\n");
    gets(pf);
    if (isTautology(pf)) {
        printf("重言式\n");
    } else if (isTautology(strcat(pf, "!"))) {
        printf("矛盾式\n");
    } else {
        printf("普通命题\n");
    }
    return 0;
}

使用方法：

1. 编译程序：`gcc -o polish_notation polish_notation.c`
2. 运行程序：`./polish_notation`
3. 输入波兰符号法公式，例如：`-!&PQ|!P!Q`
4. 程序输出公式类型，例如：`重言式`