删除额外的括号

remove extra parenthesis

本文关键字：删除      更新时间：2023-10-16

问题：

从字符串中删除额外的括号。
例如

    ((a+b))*c       => (a+b)*c  
    (a+b)+c         => (a+b)+c  
    ((a+b)/(c+d))   => ((a+b)/(c+d))   
    (a+(((b-c)))*d) => (a+(b-c)*d)  and so on.

我提出了以下解决方案：
方法：我通过字符串扫描，并记住（使用地图）开口括号的索引以及是否额外（默认情况下它是额外的）。如果我找到一个闭合括号，我会从MAP中检查相应的打开括号，如果是额外的，则两者都会删除。

void removeExtraParentheses(string& S){
  map<int, bool> pmap;
  for(int i = 0; i < S.size(); i++){
    map<int, bool>::iterator it;
    if(S.at(i) == '('){
        pmap[i] = true;
    }
    else if(S.at(i) == ')'){
        it = pmap.end();
        it--;
        if(!(*it).second){
            pmap.erase(it);
        }
        else{
            S.erase(S.begin() + i);
            S.erase(S.begin() + (*it).first);
            pmap.erase(it);
            i = i - 2;
        }
    }
    else{
        if(!pmap.empty()){
            it = pmap.end();
            it--;
            (*it).second= false;
        }
    }
  }
}

时间复杂性：O（n2）
空间：o（n）
我对解决方案不太满意，因为我正在使用额外的存储空间并在二次时间内进行。

我们可以在o（n）时间和o（1）空间中执行此操作吗？如果不是，最好的办法可以做什么？

构建一个表达树，然后以最低限度再生表达式括号。原始的任何括号都不在生成是不必要的。

一个简单，几乎正确的解决方案是将优先级分配给每个操作员。然后，您需要任何直接节点的括号在您正在使用的节点下的是一个操作员，其具有较低的操作员比节点的优先级；例如，如果您在*（乘法）节点，两个子节点之一是+（加法）节点。加上一些逻辑要处理左或右装订：如果您在+节点上，右手节点也是+节点，您需要括号。

这只是部分正确的，因为C 实际上无法真正映射到优先语法：其中一些想到类型的铸造构造或三元操作员。在至少在三元操作员的情况下，特殊处理这不是那么困难。

编辑：

关于您的big-o问题：这显然不是O（1）空间，因为您需要在内存中构造整个表达式。我不要以为可以进行内存的o（1），因为有可能，您可以有无限的嵌套，您无法判断括号是否是直到不确定的时间之后或不需要。我实际上不是分析了它，但我认为及时是o（n）。上限节点的数量是n（字符串的长度），您需要访问每个节点一次。

或多或少在网络上找到...

给定输入：（（a b）*c）预期输出：（ a b）*c

假设：

  • peek（队列）只是在没有删除的情况下告诉队列前端的元素。
  • preceDence（）是一个函数，看起来是运算符的优先表

伪代码下面：

  1. 将infix表达式转换为rpn（例如，shunting-yard algo o（n））

    AB+C*

  2. 仅在队列Q

    中插入操作员

    （前） -------- *（后方）

  3. parse Postfix表达式
  4. 如果操作数，请推到stack's'
  5. 如果操作员
    • y = delete（q）
    • 如果优先级（y）>优先（peek（q）），则按（s，" pop（s）y pop（s）"）
  6. 如果优先（y）＆lt;优先（peek（q）），然后推（s，"（pop（s）y pop（s））"）
  7. S顶部的最终结果

全部应该是o（n）。

我以为我会做一个刺。这是解决我的问题的解决方案。请注意，这是伪代码，不是直接运行。

（实际上，这是C - ISH，但是自从我上次写真正的C 以来已经有一段时间了，当我打算通过算法时，我不想付出努力来使一切正确。）

queue<tuple<int, bool> > q = new queue<tuple<int, bool> >();
for (int i = 0; i < str.length; i++)
{
    char a = str.charAt(i);
    if (a == '(')
    {
        q.push(new tuple<int, bool>(i, false));
    }
    else if (a == ')')
    {
        if (q.top().bool)
        {
            // remove top.int and i from string
        }
        q.pop();
        q.top().bool = true;
    }
    else
    {
        q.top().bool = false;
    }
}

它在O(n)中完成工作并使用O(n)空间（实际上，所使用的空间量实际上是基于字符串中最深的嵌套级别，但保证它低于n）

）

（请注意，// remove top.int and i from string实际上无法在O(1)中完成。但是，如果您获得一些创意，则可以在O(1)中执行类似的操作。例如，您实际上可以为输出构建字符列表并存储迭代器而不是int，然后可以删除O（1）中的两个字符。最后，您可以通过在o（n）中的列表上迭代来构建最终字符串。另一种解决方案是实际上在假char虫的阵列（或向量）上工作，这些阵列（或矢量）要么是虚拟的，而且不包含或包含一个字符。再次，您可以通过O(1)中的虚拟替换字符。再一次，您将迭代结构并在O(n)中构建输出字符串）

相关文章：