逻辑表达式化为真值表

这个处理方法和多项式的处理方法一样。试着写了一下,发现自己对栈的应用能力还是不够,不过很感谢

supermary863的博客http://blog.csdn.net/supermary863/article/details/6363570。

然后模仿着把这个离散实验作业完成了。可能存在一些小问题,但是总体思路就是那样吧。

/*程序设计类似与多项式的计算,用双栈来实现,完成<任意个>变量的表达式的运算*/
/*变量请统一用小写字母*/
/*目前支持的逻辑运算符有~(非),V(析取,用大写字母V),^(合取,用shitf + 6), 以及->(蕴含)。
没有添加<->(只是多添加一个操作符,优先级同->,同理,有兴趣的读者可以自己实现)*/
/*程序运行方式见main函数入口。*/


#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>
#include <stack>
using namespace std;

class TrueFalseTable
{
protected:
    string read;    //限定表达式变量为小写字母。
    char x[10];     //存储变量。
    int x_num;      //变量数。
    int value[10]; //下标对应变量的值0或1。
    int Ans;    //每行真值表计算一个值。
    /*打印开头部分*/
    void printTitle()
    {
        for(int i = 0; i < x_num; i ++)
        {
            printf("%c\t", x[i]);
        }
        cout << read << endl;
        printf("-------------------------------------------------\n");
    }
    /*检测是否穷举了所有的真值表*/
    bool check_end()
    {
        for(int i
  • 0
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
为了能够输出任意逻辑表达式真值表,我们需要先将逻辑表达式转化为逆波兰表达式,然后再使用栈来计算表达式的值,并输出真值表。下面是一个简单的C语言程序,可以实现这个功能: ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX_EXPR_LEN 100 // 定义逻辑表达式的最大长度 typedef enum { OPERAND, // 操作数 OPERATOR // 操作符 } TokenType; typedef struct { TokenType type; // Token类型 union { char operator; // 操作符 int operand; // 操作数 } value; } Token; typedef struct StackNode { Token data; struct StackNode *next; } StackNode, *Stack; Stack createStack() { Stack stack = (Stack) malloc(sizeof(StackNode)); stack->next = NULL; return stack; } int isEmpty(Stack stack) { return stack->next == NULL; } Token top(Stack stack) { Token token; if (!isEmpty(stack)) { token = stack->next->data; } return token; } void push(Stack stack, Token token) { StackNode *newNode = (StackNode *) malloc(sizeof(StackNode)); newNode->data = token; newNode->next = stack->next; stack->next = newNode; } Token pop(Stack stack) { Token token; if (!isEmpty(stack)) { StackNode *p = stack->next; token = p->data; stack->next = p->next; free(p); } return token; } int isOperator(char c) { return c == '~' || c == '&' || c == '|' || c == '^'; } int priority(char c) { switch (c) { case '~': return 3; case '&': return 2; case '|': return 1; case '^': return 0; default: return -1; } } void infixToPostfix(char *infix, Token *postfix, int *postfixSize) { Stack stack = createStack(); int i = 0; int j = 0; while (infix[i] != '\0') { if (infix[i] >= '0' && infix[i] <= '9') { Token token = {OPERAND, .value.operand = infix[i] - '0'}; postfix[j++] = token; } else if (isOperator(infix[i])) { while (!isEmpty(stack) && priority(top(stack).value.operator) >= priority(infix[i])) { postfix[j++] = pop(stack); } Token token = {OPERATOR, .value.operator = infix[i]}; push(stack, token); } else if (infix[i] == '(') { Token token = {OPERATOR, .value.operator = infix[i]}; push(stack, token); } else if (infix[i] == ')') { while (top(stack).value.operator != '(') { postfix[j++] = pop(stack); } pop(stack); } i++; } while (!isEmpty(stack)) { postfix[j++] = pop(stack); } *postfixSize = j; } int evaluatePostfix(Token *postfix, int postfixSize, int *values) { Stack stack = createStack(); for (int i = 0; i < postfixSize; i++) { if (postfix[i].type == OPERAND) { push(stack, postfix[i]); } else if (postfix[i].type == OPERATOR) { if (postfix[i].value.operator == '~') { Token operand = pop(stack); Token result = {OPERAND, .value.operand = !operand.value.operand}; push(stack, result); } else { Token operand2 = pop(stack); Token operand1 = pop(stack); int value1 = values[operand1.value.operand]; int value2 = values[operand2.value.operand]; int result; switch (postfix[i].value.operator) { case '&': result = value1 && value2; break; case '|': result = value1 || value2; break; case '^': result = value1 ^ value2; break; } Token token = {OPERAND, .value.operand = result}; push(stack, token); } } } int result = pop(stack).value.operand; return result; } void printTruthTable(char *expr) { Token postfix[MAX_EXPR_LEN]; int postfixSize = 0; infixToPostfix(expr, postfix, &postfixSize); int numVars = 0; int values[MAX_EXPR_LEN]; for (int i = 0; i < postfixSize; i++) { if (postfix[i].type == OPERAND) { values[postfix[i].value.operand] = 0; numVars = postfix[i].value.operand + 1 > numVars ? postfix[i].value.operand + 1 : numVars; } } printf("%s\n", expr); for (int i = 0; i < numVars; i++) { printf("x%d\t", i); } printf("result\n"); for (int i = 0; i < (1 << numVars); i++) { for (int j = 0; j < numVars; j++) { values[j] = (i >> j) & 1; printf("%d\t", values[j]); } int result = evaluatePostfix(postfix, postfixSize, values); printf("%d\n", result); } } int main() { char expr[MAX_EXPR_LEN]; printf("请输入逻辑表达式:\n"); scanf("%s", expr); printTruthTable(expr); return 0; } ``` 在这个程序中,我们定义了一个 `Token` 结构体,用于表示逆波兰表达式中的每个元素,包括操作符和操作数。然后我们使用两个函数 `infixToPostfix` 和 `evaluatePostfix` 分别将中缀表达式转化为逆波兰表达式,并计算逆波兰表达式的值。最后,我们使用 `printTruthTable` 函数输出逻辑表达式真值表。 在 `printTruthTable` 函数中,我们首先将逻辑表达式转化为逆波兰表达式,并统计变量的数量。然后我们遍历所有可能的变量取值,计算逻辑表达式的值,并输出真值表。注意,我们使用了位运算来生成所有可能的变量取值。 你可以在命令行中输入逻辑表达式,程序会输出该表达式真值表

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值