C ++中简单堆栈问题的出乎意料的答案

如何解决C ++中简单堆栈问题的出乎意料的答案

class Solution {
public:
bool isValid(string s) {
    map<char,char> m;
    m[')'] = '(';
    m['}'] = '{';
    m[']'] = '[';
    
    stack<char> st;
    
    if(s[0] != '(' || s[0] != '{' || s[0] != '[')
        return "false";
    
    for(int i = 0; i<s.length(); i++)
    {
        if(s[i] == '(' || s[i]== '{' || s[i]== '[')
        {
            st.push(s[i]);
        }
        else if(st.top() == m[s[i]])
        {
            st.pop();
        }
        else if(st.top() != m[s[i]])
        {
            return "false";
        }

    }
    
    if(st.empty())
        return "true";
    else
        return "false";
}
};

对于诸如“（]”这样的基本示例，代码失败。我不知道这是怎么可能的。

1. （首先进入堆栈

2. （不是]的地图

因此它应该返回“ false”。但它返回true。

解决方法

关于您的表情：

(s[0] != '(' || s[0] != '{' || s[0] != '[')

首先，除非s[0]是一个奇怪的量子变量，该变量可以同时是三件事，否则该表达式从不为假。考虑一些可能性：

Character  != '('  != '{'  != '['  || all
---------  ------  ------  ------  ------
    (       false   true    true    true
    {       true    false   true    true
    [       true    true    false   true
    x       true    true    true    true

如您所见，每个 字符都会将该表达式评估为true。您可能应该使用&&而不是||。

---

此外，您还从函数中返回了 C风格的字符串，该字符串作为非零指针，将在布尔值上下文中转换为true，如：

#include <iostream>
bool returnT() { return "true"; }
bool returnF() { return "false"; }
int main() {
    std::cout << returnT() << '\n';
    std::cout << returnF() << '\n';
}

输出：

1
1

---

所以我更倾向于从这样的事情开始：

class Solution {
public:
    bool isValid(string s) {
        stack<char> st;
        map<char,char> m;
        m[')'] = '('; m['}'] = '{'; m[']'] = '[';

        if (s[0] != '(' && s[0] != '{' && s[0] != '[') {
            return false;
        }

        for (int i = 0; i < s.length(); ++i) {
            if (s[i] == '(' || s[i]== '{' || s[i]== '[') {
                st.push(s[i]);
            } else if (st.top() == m[s[i]]) {
                st.pop();
            } else if (st.top() != m[s[i]]) {
               return false;
            }
        }

        return st.empty();
    }
};

---

但是要当心一件事。如果您将有效的输入字符限制在六个括号内，则应该可以。

但是如果您想允许其他不影响堆栈的字符，例如：

[14^{6+(2x3)}]

然后您的代码将不起作用，因为第一个1字符将被视为不匹配。要解决此问题，您需要对其进行修改以考虑到它们。

例如：

for (int i = 0; i < s.length(); ++i) {
    if (s[i] == '(' || s[i]== '{' || s[i]== '[') {
        // Handle open brackets: store.

        st.push(s[i]);
    } else if (s[i] == ')' || s[i]== '}' || s[i]== ']') {
        // Handle close brackets: check.

        if (st.top() == m[s[i]]) {
            st.pop();
        } else {
            return false;
        }
    }

    // Anything else is just a "noise" character,ignore.
}

,

很明显，ASCII代码中的'）'必须接近'（'。

class Solution {
public:
    bool isValid(string s) {
        stack<char> st; st.push('\0');
        for (auto c : s) {
            if (isalpha(c)) continue;
            else if (c - st.top() <= 3 && c - st.top() > 0)
                st.pop();
            else
                st.push(c);
        }
        return st.size() == 1;
    }
};
int main() {
    Solution solu;
    cout << solu.isValid("[](){}") << endl;
    cout << solu.isValid(")(") << endl;
}