手打栈括号配对cpp

### 回答1：
下面是一个简单的手打栈实现栈括号配对的cpp代码：

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

using namespace std;

bool isMatchingPair(char character1, char character2)
{
    if (character1 == '(' && character2 == ')')
        return true;
    else if (character1 == '{' && character2 == '}')
        return true;
    else if (character1 == '[' && character2 == ']')
        return true;
    else
        return false;
}

bool areParenthesesBalanced(string expr)
{
    stack<char> s;
    for (int i = 0; i < expr.length(); i++)
    {
        if (expr[i] == '(' || expr[i] == '{' || expr[i] == '[')
            s.push(expr[i]);
        else if (expr[i] == ')' || expr[i] == '}' || expr[i] == ']')
        {
            if (s.empty() || !isMatchingPair(s.top(), expr[i]))
                return false;
            else
                s.pop();
        }
    }
    return s.empty();
}

int main()
{
    string expr = "{()}[]";
    if (areParenthesesBalanced(expr))
        cout << "Balanced" << endl;
    else
        cout << "Not Balanced" << endl;
    return 0;
}

该程序首先定义了一个 `isMatchingPair` 函数，用于检查两个字符是否匹配。然后定义了一个 `areParenthesesBalanced` 函数，该函数使用栈来检查表达式中的括号是否匹配。最后在主函数中调用 `areParenthesesBalanced` 函数来检查表达式是否平衡，并输出结果。

### 回答2：
下面是一个用C++编写的手打栈来配对括号的示例程序：

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

bool checkBrackets(const std::string& expression) {
    std::stack<char> bracketStack;
    
    for (char ch : expression) {
        if (ch == '(' || ch == '[' || ch == '{') {
            bracketStack.push(ch);
        }
        else if (ch == ')' || ch == ']' || ch == '}') {
            if (bracketStack.empty()) {
                return false; // 括号栈为空，说明前面没有相应的左括号
            }
            
            // 检查当前字符是否和栈顶元素对应
            char top = bracketStack.top();
            if ((ch == ')' && top == '(') ||
                (ch == ']' && top == '[') ||
                (ch == '}' && top == '{')) {
                bracketStack.pop();
            }
            else {
                return false; // 括号不匹配
            }
        }
    }
    
    return bracketStack.empty(); // 如果最后括号栈为空，说明所有括号都配对成功
}

int main() {
    std::string expression;
    std::cout << "请输入一个表达式：";
    std::cin >> expression;
    
    if (checkBrackets(expression)) {
        std::cout << "括号配对正确！" << std::endl;
    }
    else {
        std::cout << "括号配对错误！" << std::endl;
    }
    
    return 0;
}

这个程序中，我们使用了一个字符类型的栈 `bracketStack` 来存储左括号，并在遇到右括号时进行匹配。如果一个右括号出现时，栈为空，或者该右括号与栈顶元素不匹配，则表达式中的括号配对错误。最后，我们检查栈是否为空，以确保所有左括号都能被成功配对。

### 回答3：
手打栈括号配对的C++实现如下：

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

using namespace std;

bool isParenthesesMatched(string str) {
    stack<char> parenthesesStack;

    for (int i = 0; i < str.length(); i++) {
        char currentChar = str[i];

        // 如果字符是左括号，则将其压入栈中
        if (currentChar == '(' || currentChar == '[' || currentChar == '{') {
            parenthesesStack.push(currentChar);
        }
        // 如果字符是右括号，则检查栈顶元素是否与之匹配
        else if (currentChar == ')' || currentChar == ']' || currentChar == '}') {
            // 如果栈为空或栈顶元素与当前括号类型不匹配，则表明括号未配对
            if (parenthesesStack.empty() || ((!parenthesesStack.empty() && parenthesesStack.top() != '(') && currentChar == ')') ||
                ((!parenthesesStack.empty() && parenthesesStack.top() != '[') && currentChar == ']') ||
                ((!parenthesesStack.empty() && parenthesesStack.top() != '{') && currentChar == '}')) {
                return false;
            }
            // 如果栈顶元素与当前括号类型匹配，则将其弹出栈
            parenthesesStack.pop();
        }
    }

    // 如果栈中还有剩余未匹配的左括号，则返回false
    if (!parenthesesStack.empty()) {
        return false;
    }
    
    return true;
}

int main() {
    string parenthesesExpression;
    cout << "请输入括号表达式：";
    cin >> parenthesesExpression;

    if (isParenthesesMatched(parenthesesExpression)) {
        cout << "括号配对正确！" << endl;
    } else {
        cout << "括号配对错误！" << endl;
    }

    return 0;
}

以上程序实现了一个函数`isParenthesesMatched`，用于判断给定的括号表达式是否括号配对正确。通过使用栈来检查左右括号是否配对。程序首先遍历每个字符，如果字符是左括号，则将其压入栈中；如果是右括号，则检查栈顶元素是否与之匹配，若匹配，则将其弹出栈。最后，如果栈为空，表示所有的括号都配对成功，返回true；否则，表示还有未匹配的括号，返回false。在main函数中，用户可以输入一个括号表达式，然后调用`isParenthesesMatched`函数判断括号配对是否正确，并输出结果。