2023-07-19：布尔表达式 是计算结果不是 true 就是 false 的表达式 有效的表达式需遵循以下约定： ‘t‘，运算结果为 true ‘f‘，运算结果为 false ‘!(subExpr
2023-07-19：布尔表达式 是计算结果不是 true 就是 false 的表达式
有效的表达式需遵循以下约定：
't'，运算结果为 true
'f'，运算结果为 false
'!(subExpr)'，运算过程为对内部表达式 subExpr 进行 逻辑非（NOT）运算
'&(subExpr1, subExpr2, ..., subExprn)'
运算过程为对 2 个或以上内部表达式
subExpr1, subExpr2, ..., subExprn 进行 逻辑与（AND）运算
'|(subExpr1, subExpr2, ..., subExprn)'
运算过程为对 2 个或以上内部表达式
subExpr1, subExpr2, ..., subExprn 进行 逻辑或（OR）运算
给你一个以字符串形式表述的 布尔表达式 expression，返回该式的运算结果。
题目测试用例所给出的表达式均为有效的布尔表达式，遵循上述约定。
输入：expression = "&(|(f))"。
输出：false。
答案2023-07-19：
大体过程如下：
1.主函数main中定义了一个布尔表达式expression为"&(|(f))"，该表达式需要计算结果。
2.调用parseBoolExpr函数，并将布尔表达式作为参数传递给它。
3.parseBoolExpr函数中定义了一个内部递归函数f，接收两个参数：表达式字符串exp和当前字符索引index。
4.函数f中首先获取当前索引处的字符judge，判断其类型。
5.如果judge为't'，返回结果为true，索引保持不变。
6.如果judge为'f'，返回结果为false，索引保持不变。
7.如果judge为其他字符，进行进一步判断。
8.如果judge为'!'，则递归调用f函数，并将索引加1作为参数，获取递归调用的结果next，对该结果执行逻辑非运算，返回结果为!next.ans，索引更新为next.end + 1。
9.如果judge为'&'或'|'，则设置布尔变量ans为相应的值（true或false），并在循环中处理多个子表达式。
10.在循环中，当当前字符不是')'时，执行以下操作：
- 如果当前字符是','，则将索引加1，跳过逗号字符。
- 否则，递归调用`f`函数，并将当前索引作为参数获取递归结果`next`。
- 根据父表达式的运算符进行相应的逻辑运算，更新布尔变量`ans`的值。
- 更新索引为`next.end + 1`。
11.循环结束后，返回结果为Info{ans, index}，其中ans为布尔表达式的计算结果，index为当前索引。
12.返回到parseBoolExpr函数，获取f函数的结果Info，返回Info.ans作为布尔表达式的最终计算结果。
13.输出最终结果。根据给定的表达式"&(|(f))"，计算结果为false，打印结果false。
时间复杂度：假设表达式字符串的长度为n，递归过程涉及到遍历字符串中的每个字符，因此时间复杂度为O(n)。
空间复杂度：递归调用过程中会使用额外的栈空间来保存递归的状态，最坏情况下递归的深度可以达到n，因此空间复杂度为O(n)。
go完整代码如下：
package main
import (
"fmt"
)
type Info struct {
ans bool
end int
}
func parseBoolExpr(expression string) bool {
return f([]rune(expression), 0).ans
}
func f(exp []rune, index int) Info {
judge := exp[index]
if judge == 'f' {
return Info{false, index}
} else if judge == 't' {
return Info{true, index}
} else {
var ans bool
index += 2
if judge == '!' {
next := f(exp, index)
ans = !next.ans
index = next.end + 1
} else {
ans = judge == '&'
for exp[index] != ')' {
if exp[index] == ',' {
index++
} else {
next := f(exp, index)
if judge == '&' {
if !next.ans {
ans = false
}
} else {
if next.ans {
ans = true
}
}
index = next.end + 1
}
}
}
return Info{ans, index}
}
}
func main() {
expression := "&(|(f))"
result := parseBoolExpr(expression)
fmt.Println(result)
}
rust代码如下：
fn main() {
let expression = "&(|(f))";
let result = parse_bool_expr(expression.to_string());
println!("{}", result);
}
fn parse_bool_expr(expression: String) -> bool {
let exp: Vec<char> = expression.chars().collect();
let info = f(&exp, 0);
info.ans
}
struct Info {
ans: bool,
end: usize,
}
fn f(exp: &[char], index: usize) -> Info {
let judge = exp[index];
if judge == 'f' {
return Info {
ans: false,
end: index,
};
} else if judge == 't' {
return Info {
ans: true,
end: index,
};
} else {
let mut ans: bool;
let mut index = index + 2;
if judge == '!' {
let next = f(exp, index);
ans = !next.ans;
index = next.end + 1;
} else {
ans = judge == '&';
while exp[index] != ')' {
if exp[index] == ',' {
index += 1;
} else {
let next = f(exp, index);
if judge == '&' {
if !next.ans {
ans = false;
}
} else {
if next.ans {
ans = true;
}
}
index = next.end + 1;
}
}
}
Info { ans, end: index }
}
}
c++完整代码如下：
#include <iostream>
#include <string>
using namespace std;
struct Info {
bool ans;
// 结束下标！
int end;
Info(bool a, int e) {
ans = a;
end = e;
}
};
Info f(const string& exp, int index) {
char judge = exp[index];
if (judge == 'f') {
return Info(false, index);
}
else if (judge == 't') {
return Info(true, index);
}
else {
// !
// &
// |
// 再说！
bool ans;
// ! ( ?
// i i+1 i+2
// & ( ?
// i i+1 i+2
// | ( ?
// i i+1 i+2
index += 2;
if (judge == '!') {
// ! ( ?...... )
// i i+1 i+2
Info next = f(exp, index);
ans = !next.ans;
index = next.end + 1;
}
else {
// &
// i
// judge == '&' 或者 judge == '|'
ans = judge == '&';
while (exp[index] != ')') {
if (exp[index] == ',') {
index++;
}
else {
Info next = f(exp, index);
if (judge == '&') {
if (!next.ans) {
ans = false;
}
}
else {
if (next.ans) {
ans = true;
}
}
index = next.end + 1;
}
}
}
return Info(ans, index);
}
}
bool parseBoolExpr(const string& expression) {
return f(expression, 0).ans;
}
int main() {
string expression = "&(|(f))";
cout << boolalpha << parseBoolExpr(expression) << endl;
return 0;
}
c完整代码如下：
#include <stdbool.h>
#include<stdio.h>
typedef struct Info {
bool ans;
int end;
} Info;
Info f(char* exp, int index);
bool parseBoolExpr(char* expression) {
return f(expression, 0).ans;
}
Info f(char* exp, int index) {
char judge = exp[index];
Info info;
if (judge == 'f') {
info.ans = false;
info.end = index;
}
else if (judge == 't') {
info.ans = true;
info.end = index;
}
else {
bool ans;
index += 2;
if (judge == '!') {
Info next = f(exp, index);
ans = !next.ans;
index = next.end + 1;
}
else {
ans = judge == '&';
while (exp[index] != ')') {
if (exp[index] == ',') {
index++;
}
else {
Info next = f(exp, index);
if (judge == '&') {
if (!next.ans) {
ans = false;
}
}
else {
if (next.ans) {
ans = true;
}
}
index = next.end + 1;
}
}
}
info.ans = ans;
info.end = index;
}
return info;
}
int main() {
char* expression = "&(|(f))";
bool result = parseBoolExpr(expression);
printf("%d\n", result);
return 0;
}
