实现功能：给定布尔表达式，请计算得到表达式最终值。 输入：只包含1（true）和0（false）、与（*表示）、或（｜表示）与小括号形成的表达式。 输出：0（表达式结果为假）、1（表达式结果为真）

实现功能：给定布尔表达式，请计算得到表达式最终值。

输入：只包含1（true）和0（false）、与（*表示）、或（｜表示）与小括号形成的表达式。

输出：0（表达式结果为假）、1（表达式结果为真）

基于Monster 组和GPT的调写：

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

// 判断一个字符是否是操作符
bool isOperator(char c) {
    return c == '*' || c == '|';
}

// 计算表达式的值
bool calculate(bool a, bool b, char op) {
    if (op == '*') {
        return a && b;
    } else {
        return a || b;
    }
}

// 将表达式转换为后缀表达式，并计算其值
bool evaluateExpression(string expr) {
    stack<char> s;  // 存放操作符的栈
    stack<bool> values;  // 存放操作数的栈
    for (int i = 0; i < expr.length(); i++) {
        char c = expr[i];
        if (c == '(') {
            s.push(c);
        } else if (c == ')') {
            while (!s.empty() && s.top() != '(') {
                char op = s.top();
                s.pop();
                bool b = values.top();
                values.pop();
                bool a = values.top();
                values.pop();
                values.push(calculate(a, b, op));
            }
            s.pop();  // 弹出左括号
        } else if (isOperator(c)) {
            while (!s.empty() && isOperator(s.top())) {
                char op = s.top();
                s.pop();
                bool b = values.top();
                values.pop();
                bool a = values.top();
                values.pop();
                values.push(calculate(a, b, op));
            }
            s.push(c);
        } else {  // 操作数
            values.push(c == '1');
        }
    }
    while (!s.empty()) {
        char op = s.top();
        s.pop();
        bool b = values.top();
        values.pop();
        bool a = values.top();
        values.pop();
        values.push(calculate(a, b, op));
    }
    return values.top();
}

int main() {
    string expr;
    cin >> expr;
    cout << evaluateExpression(expr) << endl;
    return 0;
}

引用new bing部分回答作答：
以下是一个简单的C++代码示例，可以计算给定布尔表达式的值：

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

int precedence(char op) {
    if (op == '*') return 2;
    if (op == '|') return 1;
    return 0;
}

bool evaluate(bool left, char op, bool right) {
    if (op == '*') return left && right;
    if (op == '|') return left || right;
    return false;
}

bool evaluateExpression(string expression) {
    stack<bool> values;
    stack<char> operators;
    for (int i = 0; i < expression.length(); i++) {
        char c = expression[i];
        if (c == '0' || c == '1') {
            values.push(c - '0');
        } else if (c == '(') {
            operators.push(c);
        } else if (c == ')') {
            while (!operators.empty() && operators.top() != '(') {
                char op = operators.top();
                operators.pop();
                bool right = values.top();
                values.pop();
                bool left = values.top();
                values.pop();
                bool result = evaluate(left, op, right);
                values.push(result);
            }
            operators.pop(); // pop the '('
        } else if (c == '*' || c == '|') {
            while (!operators.empty() && precedence(c) <= precedence(operators.top())) {
                char op = operators.top();
                operators.pop();
                bool right = values.top();
                values.pop();
                bool left = values.top();
                values.pop();
                bool result = evaluate(left, op, right);
                values.push(result);
            }
            operators.push(c);
        }
    }
    while (!operators.empty()) {
        char op = operators.top();
        operators.pop();
        bool right = values.top();
        values.pop();
        bool left = values.top();
        values.pop();
        bool result = evaluate(left, op, right);
        values.push(result);
    }
    return values.top();
}

int main() {
    string expression = "(1*1)|((0|1)*1)";
    bool result = evaluateExpression(expression);
    cout << result << endl; // output: 1
    return 0;
}

此示例代码使用了栈（stack）数据结构来解析和计算表达式。它首先遍历表达式中的每个字符，并根据它们的类型执行相应的操作。

具体来说，当程序遇到一个数字字符时，它将该数字推入值（values）栈中。当程序遇到一个左括号字符时，它将该字符推入运算符（operators）栈中。当程序遇到一个右括号字符时，它将一直弹出运算符栈中的操作符，直到找到与该右括号匹配的左括号字符。在这个过程中，程序将弹出值栈中的相应操作数，并使用evaluate函数计算相应的结果，并将该结果推回值栈中。当程序遇到一个操作符字符时，它将一直弹出运算符栈中的操作符，直到栈顶的操作符的优先级小于或等于当前操作符的优先级。

• 这个问题的回答你可以参考下: https://ask.csdn.net/questions/7664719

该回答引用chatgpt:

#include <iostream>
#include <stack>
#include <string>

using namespace std;

// 优先级定义
int priority(char op) {
    if (op == '|') {
        return 1;
    } else if (op == '*') {
        return 2;
    } else {
        return 0;
    }
}

// 计算表达式
int evaluate(string expression) {
    stack<char> operators;
    stack<int> operands;
    for (int i = 0; i < expression.length(); i++) {
        char ch = expression[i];
        if (ch == ' ') {
            continue;
        } else if (ch == '0' || ch == '1') {
            operands.push(ch - '0');
        } else if (ch == '(') {
            operators.push(ch);
        } else if (ch == ')') {
            while (operators.top() != '(') {
                char op = operators.top();
                operators.pop();
                int operand2 = operands.top();
                operands.pop();
                int operand1 = operands.top();
                operands.pop();
                if (op == '|') {
                    operands.push(operand1 || operand2);
                } else if (op == '*') {
                    operands.push(operand1 && operand2);
                }
            }
            operators.pop(); // 弹出左括号
        } else {
            while (!operators.empty() && priority(operators.top()) >= priority(ch)) {
                char op = operators.top();
                operators.pop();
                int operand2 = operands.top();
                operands.pop();
                int operand1 = operands.top();
                operands.pop();
                if (op == '|') {
                    operands.push(operand1 || operand2);
                } else if (op == '*') {
                    operands.push(operand1 && operand2);
                }
            }
            operators.push(ch);
        }
    }
    while (!operators.empty()) {
        char op = operators.top();
        operators.pop();
        int operand2 = operands.top();
        operands.pop();
        int operand1 = operands.top();
        operands.pop();
        if (op == '|') {
            operands.push(operand1 || operand2);
        } else if (op == '*') {
            operands.push(operand1 && operand2);
        }
    }
    return operands.top();
}

int main() {
    string expression = "(1*1)|(0*1)";
    int result = evaluate(expression);
    cout << "Result: " << result << endl;
    return 0;
}

该实现使用两个栈来计算表达式，一个栈用于存储运算符，另一个栈用于存储操作数。遍历表达式的每个字符，如果是数字，则将其压入操作数栈；如果是运算符，则将其与栈顶运算符比较优先级，如果优先级更高，则将其压入栈中，否则将栈顶运算符弹出并执行相应操作。当遇到左括号时，将其压入栈中；当遇到右括号时，弹出栈中的运算符，直到遇到左括号。最后，操作数栈中仅剩一个元素，即为表达式的最终值。

class Solution {
    public boolean parseBoolExpr(String expression) {
        Deque<Character> tfs = new ArrayDeque<>(), opts = new ArrayDeque<>();
        for (char c : expression.toCharArray()) {
            if (c == ',')
                continue;
            else if (c == 't' || c == 'f' || c == '(')
                tfs.addLast(c);
            else if (c == '|' || c == '&' || c == '!')
                opts.addLast(c);
            else if (c == ')') {
                char op = opts.pollLast(), cur = ' ';
                while (!tfs.isEmpty() && tfs.peekLast() != '(') {
                    char top = tfs.pollLast();
                    cur = cur == ' ' ? top : calBool(top, cur, op);
                }
                if (op == '!')
                    cur = cur == 't' ? 'f' : 't';
                tfs.pollLast();
                tfs.addLast(cur);
            }
        }
        return tfs.peekLast() == 't';
    }
    char calBool(char cx, char cy, char op) {
        boolean bx = cx == 't', by = cy == 't';
        boolean res = op == '|' ? bx | by : bx & by;
        return res ? 't' : 'f';
    }
}

基于new Bing的编写：
【c实现】

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_SIZE 100

// 定义一个栈结构体
typedef struct {
  int top;
  char data[MAX_SIZE];
} Stack;

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

// 入栈操作
void push(Stack *s, char c) {
  if (s->top == MAX_SIZE - 1) {
    printf("error: stack overflow!");
    exit(-1);
  }
  s->data[++s->top] = c;
}

// 出栈操作
char pop(Stack *s) {
  if (s->top == -1) {
    printf("error: stack underflow!");
    exit(-1);
  }
  return s->data[s->top--];
}

// 计算逻辑运算表达式
int calculate(char exp[]) {
  Stack s_op; // 操作符栈
  Stack s_val; // 操作数栈

  init(&s_op);
  init(&s_val);
  
  int exp_len = strlen(exp);
  char c;

  for (int i = 0; i < exp_len; i++) {
    c = exp[i];
    if (c == '(') {
      push(&s_op, c);
    } else if (c == ')') {
      while (s_op.data[s_op.top] != '(') {
        char op = pop(&s_op);
        int v2 = pop(&s_val);
        int v1 = pop(&s_val);

        switch (op) {
          case '&':
            push(&s_val, v1 && v2);
            break;
          case '|':
            push(&s_val, v1 || v2);
            break;
          default:
            printf("error: invalid operator");
            exit(-1);
        }
      }
      pop(&s_op);
    } else if (c == '&' || c == '|') {
      while (s_op.top >= 0 && s_op.data[s_op.top] != '(') {
        char op = pop(&s_op);
        int v2 = pop(&s_val);
        int v1 = pop(&s_val);

        switch (op) {
          case '&':
            push(&s_val, v1 && v2);
            break;
          case '|':
            push(&s_val, v1 || v2);
            break;
          default:
            printf("error: invalid operator");
            exit(-1);
        }
      }
      push(&s_op, c);
    } else {
      push(&s_val, c - '0');
    }
  }

  while (s_op.top >= 0) {
    char op = pop(&s_op);
    int v2 = pop(&s_val);
    int v1 = pop(&s_val);

    switch (op) {
      case '&':
        push(&s_val, v1 && v2);
        break;
      case '|':
        push(&s_val, v1 || v2);
        break;
      default:
        printf("error: invalid operator");
        exit(-1);
    }
  }

  return pop(&s_val);
}

int main() {
  char exp[MAX_SIZE];
  scanf("%s", exp);

  printf("%d", calculate(exp));

  return 0;
}

【c++实现】

#include <iostream>
#include <stack>
#include <string>

using namespace std;

// 计算逻辑运算表达式
int calculate(string exp) {
  stack<char> s_op; // 操作符栈
  stack<int> s_val; // 操作数栈

  int exp_len = exp.length();
  char c;

  for (int i = 0; i < exp_len; i++) {
    c = exp[i];
    if (c == '(') {
      s_op.push(c);
    } else if (c == ')') {
      while (s_op.top() != '(') {
        char op = s_op.top();
        s_op.pop();
        int v2 = s_val.top();
        s_val.pop();
        int v1 = s_val.top();
        s_val.pop();

        switch (op) {
          case '&':
            s_val.push(v1 && v2);
            break;
          case '|':
            s_val.push(v1 || v2);
            break;
          default:
            cout << "error: invalid operator" << endl;
            exit(-1);
        }
      }
      s_op.pop(); // 弹出'('
    } else if (c == '&' || c == '|') {
      while (!s_op.empty() && s_op.top() != '(') {
        char op = s_op.top();
        s_op.pop();
        int v2 = s_val.top();
        s_val.pop();
        int v1 = s_val.top();
        s_val.pop();

        switch (op) {
          case '&':
            s_val.push(v1 && v2);
            break;
          case '|':
            s_val.push(v1 || v2);
            break;
          default:
            cout << "error: invalid operator" << endl;
            exit(-1);
        }
      }
      s_op.push(c);
    } else {
      s_val.push(c - '0'); // 将字符转换为整数存入操作数栈
    }
  }

  while (!s_op.empty()) {
    char op = s_op.top();
    s_op.pop();
    int v2 = s_val.top();
    s_val.pop();
    int v1 = s_val.top();
    s_val.pop();

    switch (op) {
      case '&':
        s_val.push(v1 && v2);
        break;
      case '|':
        s_val.push(v1 || v2);
        break;
      default:
        cout << "error: invalid operator" << endl;
        exit(-1);
    }
  }

  return s_val.top();
}

int main() {
  string exp;
  cout << "Please input a logical expression: ";
  cin >> exp;

  cout << calculate(exp) << endl;

  return 0;
}