查看使用堆栈是否相等的两个字符串

Question

目的是要有两个字符串，其中在此字符串中，有一个反戳按钮表示为 <。但是，两个字符串的输出应等于不同。

对于InputsEqual函数，当看到一个backspace按钮时，它基本上会从堆栈中弹出顶部项目。

我用其他文件对其进行了测试，但它仍然不起作用。您能查看此代码吗？

#include <iostream>
#include <cstring>
#include <string>
#include <stack>
using namespace std;
bool EqualStacks(stack<char> a, stack<char> b);
bool InputsEqual(string inputA, string inputB);
int main()
{
    string inputA = "abcde<<";
    string inputB = "abcd<e<";
    if(InputsEqual(inputA,inputB))
    {
        cout << "Inputs Equal.n";
    }
    else
    {
        cout << "Inputs are NOT Equal.n";
    }
    return 0;
}
bool EqualStack(stack<char> a, stack<char> b)
{
    for(int i = 0; i < a.size(); i++)
    {
        if(a.top() == b.top())
        {
            a.pop();
            b.pop();
        }
    }
    return (a.empty() && b.empty()) ? true:false;
} 
//If both stacks are empty, they equal
bool InputsEqual(string inputA,string inputB) 
{
    stack<char> aStack;
    stack<char> bStack;
    // string inputA;
    // cout << "Please enter a string. Press < if you want to delete something"
    // cin >> inputA; 
    for(int i = 0 ; i < inputA.length() + 1; i++)
    {
        if(inputA[i] != '')
        {    
            if(inputA[i] != '<')
            {
                aStack.push(inputA[i]);
            }
            else if(!aStack.empty())
            {
                aStack.pop();
            }
            else
            {  
                aStack.pop();
            }         
        }
    }
    for(int i = 0 ; i < inputB.length() + 1; i++)
    {
        if(inputB[i] != '') 
        {
            if(inputB[i] != '<')
            {    
                bStack.push(inputA[i]);
            }
            else if(!bStack.empty())
            {
                bStack.pop();
            }
            else
            {  
                bStack.pop();
            }
        }
    }
    return (EqualStack(aStack,bStack));
} 

//输出：字符串不等于

Answer 1

您有两个特定问题打破代码。

第一个是在InputSequal（）中的循环的第二份副本中，您按下Inputa [i]的值，应该说InputB [i]。

bStack.push(inputA[i]); // should be inputB!

其次，在将每次迭代进行比较时，您在每个迭代中调用a.size（）。问题在于，您还可以在匹配匹配时调用A.Pop（）来收缩堆栈。这会导致for循环提早中止，而堆栈不空。

快速解决方案是将循环更改为空的循环以结束，例如：

for(int i = 0; !a.empty(); i++) // fixed

而不是：

for(int i = 0; i < a.size(); i++) // broken

我还想指出其他一些可以快速清理的事情：

return (a.empty() && b.empty()) ? true:false; // redundant
return a.empty() && b.empty(); // better

和：

else if(!aStack.empty())
{
    aStack.pop(); // you call it if the stack is empty
}
else
{
    aStack.pop(); // and if its not, which is redundant!
}

pop（）似乎是空容器的不确定的，从我可以看出的情况下，请检查堆栈是否为空，在调用它是一个好练习，这只是尾随的pop（）语句是不必要的！只需擦拭即可，您应该很好。

最后，您可以避免使用inputaorb [i]！=' 0'，如果您只检查inputaorb.length（）而不是length（） 1，则可以：

for(int i = 0 ; i < inputA.length() + 1; i++)
{
    if(inputA[i] != '')
    {
        if(inputA[i] != '<')
        {
            aStack.push(inputA[i]);
        }
        else if(!aStack.empty())
        {
            aStack.pop();
        }
    }
}

可以缩短为：

for(int i = 0 ; i < inputA.length(); i++)
{
    if(inputA[i] != '<')
    {
        aStack.push(inputA[i]);
    }
    else if(!aStack.empty())
    {
        aStack.pop();
    }
}

可能还有更多的清理工作，但我想我只是指出了更明显的。祝您项目好运！

Answer 2

您永远不会比较堆叠的所有元素。循环的i < a.size()都评估了每种迭代，但是您也会更改每种迭代的a的大小。因此与每次迭代的比较是：

• 0＆lt; 3
• 1＆lt; 2
• 2＆lt; 2

因此，它将在2个比较后停止。

因此，在循环结束时return (a.empty() && b.empty()) ? true:false;将返回false，因为堆栈中仍然存在元素。

而不是您的循环，您可以使用一段时间循环：

while(!a.empty() && !b.empty()) {
  if(a.top() == b.top())
  {
    a.pop();
    b.pop();
  } else {
    break;
  }
}