当前位置:主页 > java教程 > Java C++解析布尔表达式

Java C++刷题leetcode1106解析布尔表达式

发布:2023-03-13 17:00:01 59


本站收集了一篇相关的编程文章,网友从俊远根据主题投稿了本篇教程内容,涉及到Java、C++解析布尔表达式、Java、C++、LeetCode刷题、Java C++解析布尔表达式相关内容,已被496网友关注,如果对知识点想更进一步了解可以在下方电子资料中获取。

Java C++解析布尔表达式

题目

题目要求

思路:栈【计算器】

  • 和计算器原理类似,分别用两个栈存操作数和操作符,然后到)就开始运算前面的内容,括号里运算都相同所以还是比较简单的。
  • 要注意字母t、f和布尔值truefalse的转换。

Java

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';
    }
}
  • 时间复杂度:O(n)
  • 空间复杂度:O(n)

C++

class Solution {
public:
    bool parseBoolExpr(string expression) {
        stack<char> tfs, opts;
        for (auto c : expression) {
            if (c == ',')
                continue;
            else if (c == 't' || c == 'f' || c == '(')
                tfs.push(c);
            else if (c == '|' || c == '&' || c == '!')
                opts.push(c);
            else if (c == ')') {
                char op = opts.top(), cur = ' ';
                opts.pop();
                while (!tfs.empty() && tfs.top() != '(') {
                    char top = tfs.top();
                    tfs.pop();
                    cur = cur == ' ' ? top : calBool(top, cur, op);
                }
                if (op == '!')
                    cur = cur == 't' ? 'f' : 't';
                tfs.pop();
                tfs.push(cur);
            }
        }
        return tfs.top() == 't';
    }
    char calBool(char cx, char cy, char op) {
        bool bx = cx == 't', by = cy == 't';
        bool res = op == '|' ? bx | by : bx & by;
        return res ? 't' : 'f';
    }
};
  • 时间复杂度:O(n)
  • 空间复杂度:O(n)

Rust

impl Solution {
    pub fn parse_bool_expr(expression: String) -> bool {
        let (mut tfs, mut opts) = (vec![], vec![]);
        for c in expression.chars() {
            if c == 't' || c == 'f' || c == '(' {
                tfs.push(c);
            }
            else if c == '|' || c == '&' || c == '!' {
                opts.push(c);
            }
            else if c == ')' {
                let op = opts.pop().unwrap();
                let mut cur = 'e';
                while !tfs.is_empty() && tfs[tfs.len() - 1] != '(' {
                    let top = tfs.pop().unwrap();
                    if cur == 'e' {
                        cur = top;
                    }
                    else { // fn calBool()
                        let (bx, by, mut tmp) = (top == 't', cur == 't', false);
                        if op == '|' { tmp = bx | by;
                        }
                        else { tmp = bx & by;
                        }
                        if tmp { cur = 't';
                        }
                        else { cur = 'f';
                        }
                    }
                }
                if op == '!' { // 非
                    if cur == 't' {
                        cur = 'f';
                    }
                    else {
                        cur = 't';
                    }
                }
                tfs.pop();
                tfs.push(cur);
            }
        }
        tfs.pop().unwrap() == 't'
    }
}
  • 时间复杂度:O(n)
  • 空间复杂度:O(n)

总结

  • 像是数据结构里学栈时举的计算器的例子,就循着这个思路感觉不算困难题。
  • 当然也可以递归或者只用一个栈,整体思路其实就是巧妙一点的模拟。

以上就是Java C++刷题leetcode1106解析布尔表达式的详细内容,更多关于Java C++解析布尔表达式的资料请关注码农之家其它相关文章!


参考资料

相关文章

  • Java线程安全中的有序性浅析

    发布:2023-03-27

    这篇文章主要介绍了Java线程安全中的有序性,在开发中,我们通常按照从上到下的顺序编写程序指令,并且希望cpu和编译器按照我们预先编写的顺序去执。但往往cpu和编译器为了提高性能、优化指令的执行顺序,会将我们编写好的程序指令进行重排序


  • java斗地主游戏写法实例讲解

    发布:2019-08-29

    这篇文章主要为大家详细介绍了java实现斗地主游戏,洗牌、发牌、看牌,具有一定的参考价值,感兴趣的小伙伴们可以参考一下


  • java中Redisson的看门狗机制的实现

    发布:2023-03-11

    本文主要介绍了java中Redisson的看门狗机制的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧


  • java常用工具类 UUID、Map工具类、XML工具类、数据验证工具类

    发布:2019-05-31

    这篇文章主要为大家详细介绍了java常用工具类,UUID、Map工具类、XML工具类、数据验证工具类,具有一定的参考价值,感兴趣的小伙伴们可以参考一下


  • Java后端中dto、vo、entity的区别浅析

    发布:2023-04-18

    这篇文章主要给大家介绍了关于Java后端中dto、vo、entity区别的相关资料,文中通过实例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下


  • Java ArrayList源码深入分析

    发布:2023-03-03

    ArrayList 类是一个可以动态修改的数组,与普通数组的区别就是它是没有固定大小的限制,我们可以添加或删除元素。ArrayList 继承了 AbstractList,并实现了List接口


  • 一文详解Java8中的方法引用与构造器引用

    发布:2023-03-23

    这篇文章主要为大家详细介绍了Java8中的方法引用与构造器引用的具体用法,文中的示例代码讲解详细,具有一定的借鉴价值,需要的可以参考一下


  • java进制转换工具类实现减少参数长度

    发布:2023-03-26

    这篇文章主要为大家介绍了java进制转换工具类实现减少参数长度示例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪


网友讨论