C++ 带大括号、括号和圆括号的任务

任务是检查给定字符串是否包含平衡的

{}

、

[]

和

（）

集

例如，

check（{[}]）

必须返回

false

，而

check（{[]（）}”）

必须返回

true

，等等

解决方案：

bool check(const std::string & s)
{
    constexpr auto brackets1 = "()";
    constexpr auto brackets2 = "[]";
    constexpr auto brackets3 = "{}";
    constexpr size_t brackets_pair_size = 2;
    constexpr auto brackets = "()[]{}";

    std::string s2;

    for (auto & c : s) 
    {
        if (strchr(brackets, c) != nullptr) 
        {
            s2 += c;
        }
    }

    auto brackets1_pos{ std::string::npos };
    auto brackets2_pos{ std::string::npos };
    auto brackets3_pos{ std::string::npos };

    while ((brackets1_pos = s2.find(brackets1)) != std::string::npos ||
           (brackets2_pos = s2.find(brackets2)) != std::string::npos ||
           (brackets3_pos = s2.find(brackets3)) != std::string::npos
           ) 
    {
        if (brackets1_pos != std::string::npos) {
            s2.erase(brackets1_pos, brackets_pair_size);
            continue;
        }

        if (brackets2_pos != std::string::npos) {
            s2.erase(brackets2_pos, brackets_pair_size);
            continue;
        }

        if (brackets3_pos != std::string::npos) {
            s2.erase(brackets3_pos, brackets_pair_size);
            continue;
        }
    }

    return s2.empty();
}

这个想法是： -将所有PAR、方括号和大括号复制到另一个字符串， -从第二根管柱上拆下两对支架， -检查第二个字符串是否为空

有没有办法改进算法

---

可能是一些通用正则表达式？

使用正则表达式无法执行此任务，因为它们没有内存，也无法记住括号的深度

您应该使用解析器（可能是语法分析器）来完成此任务

语法如下所示（未测试）：

示例代码：

#include <iostream>
#include <iterator>
#include <string>


class parenthesis_checker {

  template <class It>
  It parse_open_close(It first, It last, char op, char cl) const {
    if(op != *first) return first;

    It r = parse_input(first+1, last);
    if(last == r) return first;
    if(cl != *r)  return first;

    return r+1;
  }

  template <class It>
  It parse_expr(It first, It last) const {
    It r = parse_open_close(first, last, '(', ')');
    if(r != first) return r;

    r = parse_open_close(first, last, '[', ']');
    if(r != first) return r;

    r = parse_open_close(first, last, '{', '}');
    if(r != first) return r;

    return first;
  }

  template <class It>
  It parse_input(It first, It last) const {
    while(first != last) {
      It r = parse_expr(first, last);
      if(r == first) return r;
      first = r;
    }
    return first;
  }

public:
  template <class It>
  bool operator()(It first, It last) const {
    return last==parse_input(first, last);
  }

  template <class Cont>
  bool operator()(Cont value) const {
    return (*this)(value.begin(), value.end());
  }

  bool operator()(const char* str) const {
    return (*this)(std::string(str));
  }
};


int main() {
  parenthesis_checker check;

  std::cout << check("{[}]") << std::endl;
  std::cout << check("{[]()}") << std::endl;
}

#包括
#包括
#包括
类括号检查程序{
模板
它解析\打开\关闭（它第一个，它最后一个，char op，char cl）常量{
如果（op！=*first）先返回；
It r=parse_输入（第一个+1，最后一个）；
如果（last==r）首先返回；
如果（cl！=*r）先返回；
返回r+1；
}
模板
It parse_expr（It first，It last）const{
It r=parse_open_close（第一个、最后一个“（”、“）”）；
如果（r！=第一个）返回r；
r=解析打开关闭（第一个、最后一个“[”、“]”）；
如果（r！=第一个）返回r；
r=解析打开关闭（第一个，最后一个，{，}）；
如果（r！=第一个）返回r；
先返回；
}
模板
它解析_输入（It first，It last）常量{
while（第一个！=最后一个）{
It r=parse_expr（第一个，最后一个）；
如果（r==第一个），则返回r；
第一个=r；
}
先返回；
}
公众：
模板
布尔运算符（）（它先，它最后）常量{
return last==parse_输入（first，last）；
}
模板
布尔运算符（）（控制值）常量{
return（*this）（value.begin（），value.end（））；
}
布尔运算符（）（常量字符*str）常量{
返回（*this）（std:：string（str））；
}
};
int main（）{
括号检查；
std：：cout您的解决方案似乎过于复杂，我不得不承认，我并没有尽力去理解它，但我并不清楚它是否正确。
这个问题的一个非常简单的解决方案是创建一个堆栈，并遍历字符串，将左括号推到堆栈中，然后从堆栈中弹出右括号（弹出时，必须检查左括号和右括号是否匹配）

不幸的是，用正则表达式解决这个问题是不可能的，因为平衡良好的括号语言不是。
检查嵌套的大括号似乎是
std:：stack
的自然情况。在迭代输入时将大括号推到堆栈上，并在看到结束时测试是否匹配正确支撑

bool check(const std::string &expression) // balanced and nested?
{
    std::stack<char> stack;

    for (auto ch : expression) {
        switch (ch) {
        case '(': // open parenthesis
        case '<': // open angle
        case '[': // open bracket
        case '{': // open brace
            stack.push(ch);
            break;
        case ')': // close parenthesis
            if (stack.empty() || stack.top() != '(') return false;
            stack.pop();
            break;
        case '>': // close angle
            if (stack.empty() || stack.top() != '<') return false;
            stack.pop();
            break;
        case ']': // close bracket
            if (stack.empty() || stack.top() != '[') return false;
            stack.pop();
            break;
        case '}': // close brace
            if (stack.empty() || stack.top() != '{') return false;
            stack.pop();
            break;
        }
    }
    return stack.empty(); // no unmatched braces left?
}

bool检查（const std:：string&expression）//平衡和嵌套？
{
std：：堆栈；
for（自动切换：表达式）{
开关（ch）{
大小写“（”：//开括号
案例“”：//闭合角度
如果（stack.empty（）| | stack.top（）！=”您可以通过以下简单代码检查匹配的括号

int bracketMatcher(string s)
{
    list<int> *countsList = new list<int>();
    string expression = s;
    int correctBrackets = 1;

    for (int index = 0; index < expression.size(); index++) {
        char ch = expression[index];
        if (ch == '(')
        {
            countsList->push_back(index);
        }
        else if (ch == ')')
        {
            if (countsList->size() == 0)
            {
                correctBrackets = 0;
                break;
            }
            countsList->pop_back();
        }
    }
    if (countsList->size() != 0)
    {
        correctBrackets = 0;
    }
    return correctBrackets;
}

int括号匹配器（字符串s）
{
list*countsList=新列表（）；
字符串表达式=s；
int=1；
for（int index=0；indexpush_back（索引）；
}
else如果（ch=='））
{
如果（countsList->size（）==0）
{
括号=0；
打破
}
countsList->pop_back（）；
}
}
如果（countsList->size（）！=0）
{
括号=0；
}
返回括号；
}

或者，如果您想查找特定的括号类型，也可以使用以下函数

bool bracketMatcher(string s , char c)
{
    list<int> *countsList = new list<int>();
    string expression = s;
    bool correctBrackets = true;

    char secondCh =' ';
    switch (c) {
        case '(': // open parenthesis
            secondCh = ')';
            break;
        case '<': // open angle
            secondCh = '>';
            break;
        case '[': // open bracket
            secondCh = ']';
            break;
        case '{': // open brace
            secondCh = '}';
            break;
        default:

            break;
    }
    for (int index = 0; index < expression.size(); index++) {
        char ch = expression[index];
        if (ch == c)
        {
            countsList->push_back(index);
        }
        else if (ch == secondCh)
        {
            if (countsList->size() == 0)
            {
                correctBrackets = false;
                break;
            }
            countsList->pop_back();
        }
    }
    if (countsList->size() != 0)
    {
        correctBrackets = false;
    }
    return correctBrackets;
}
int main() {

    string s  = " ((hello ) (()) llll {}word <aaa>(aad))";
    //always specify the opening bracket here

    bool parenthesisMatch = bracketMatcher(s,'(');
    bool angleBracketsMatch = bracketMatcher(s,'<');
    bool bracketMatch = bracketMatcher(s,'[');
    bool bracesMatch = bracketMatcher(s, '{');

    if(parenthesisMatch && angleBracketsMatch && bracketMatch && bracesMatch) {
        cout << "found all matching brackets" << endl;
    }
    else{
        cout << "could not find all matching brackets" << endl;
    }
    return 0;
}

bool括号匹配器（字符串s，字符c）
{
list*countsList=新列表（）；
字符串表达式=s；
bool=true；
char secondCh=''；
开关（c）{
大小写“（”：//开括号
secondCh='）'；
打破
案例“”；
打破
大小写“[”：//开括号
secondCh=']'；
打破
大小写“{”：//打开大括号
secondCh='}'；
打破
违约：
打破
}
for（int index=0；indexpush_back（索引）；
}
else if（ch==secondCh）
{
如果（countsList->size（）==0）
{
括号=假；
打破
}
countsList->pop_back（）；
}
}
如果（countsList->size（）！=0）
{
括号=假；
}
返回括号；
}
int main（）{
字符串s=“（（hello）（（））llll{}word（aad））”；
//始终在此处指定开口括号
bool括号匹配=括号匹配器，'（'）；
bool angleBracketsMatch=bracketMatcher（s），请告诉我我的代码有什么问题，它总是不给出答案

string isBalanced(string s) {
stack<char> comp;
char temp;
int i;
for(i=s.size()-1;(s[i]=='}' ) || (s[i]==')' ) || (s[i]==']');i--)
{
    comp.push(s[i]);
}

if(comp.size()!=i+1)
return ("NO");

while(!comp.empty() && i>=0)
{
    temp=comp.top();
    if(temp!=s[i])
    return ("NO");
    comp.pop();
    i--;
}

return("YES");
}

字符串已平衡（字符串s）{
堆栈comp；
焦炭温度；
int i；
对于（i=s.size（）-1；（s[i]='}'）| |（s[i]=''））| |（s[i]=']）；i--）
{
复合推力（s[i]）；
}
如果（组件大小（）！=i+1）
报税表（“否”）；
而（！comp.empty（）&&i>=0）
{
温度=组件顶部（）；
如果（温度=s[i]）
报税表（“否”）；
comp.pop（）；
我--；
}
返回（“是”）；
}
正则表达式不太适合嵌套结构。另外，我认为这更适合。@JoachimPileborg，谢谢，我不知道那个社区。两个示例中都有内存泄漏。没有充分的理由在代码中使用
new
。
string isBalanced(string s) {
stack<char> comp;
char temp;
int i;
for(i=s.size()-1;(s[i]=='}' ) || (s[i]==')' ) || (s[i]==']');i--)
{
    comp.push(s[i]);
}

if(comp.size()!=i+1)
return ("NO");

while(!comp.empty() && i>=0)
{
    temp=comp.top();
    if(temp!=s[i])
    return ("NO");
    comp.pop();
    i--;
}

return("YES");
}