c ++中if语句中的多个条件（通过链接列表实现堆栈）

Question

我正在尝试创建一个程序来评估一堆括号以确保它们的正确实现（即如果括号具有开启和关闭组件，则括号有效，因此它返回“true”）。 例如[（）] {} {（）（）}为真，而[（{}）为false。

目前，我即将完成该程序，但是，堆栈评估的逻辑运算符不能正常工作。

我在Xcode中编程，问题可能与IDE有关，但不太可能。 问题： 线程1：EXC_BAD_ACCESS（代码= 1，地址= 0x0）

该计划尚未完成。 我将插入一个括号字符串作为输入，并使用递归来评估堆栈，以便删除堆栈中的所有元素，如果括号逻辑是正确的，在这种情况下（“[（） ]{}{（）（）}“） 是正确的。 所需的逻辑如下：

s.evaluate - > [] {[]}

s.evaluate - > {}

s.evaluate - > true

#include<iostream>

using namespace std;

struct node
{
    char bracket;
    node* next;
};

class stack
{
    node* top;

public:
    // constructure
    stack()
    {
        top = NULL;
    }

    void push(char bracket); // to insert an element
    void pop();  // to delete an element
    void evaluate(); // to evaluate the stack for brackets' logic
    void show(); // to show the stack

    bool isPair(node* n2, node* n1) {

        if ((n1->bracket == '(' && n2->bracket == ')') || (n1->bracket == '[' && n2->bracket == ']') || (n1->bracket == '{' && n2->bracket == '}')) {
            return true;
        } else {
            return false;
        }
    }
};

// insert an element
void stack::push(char bracket)
{
    char value = bracket;
    node* ptr;

    ptr = new node;
    ptr->bracket = value;
    ptr->next = NULL;

    if (top != NULL)
        ptr->next = top;

    top = ptr;

}

// delete an element
void stack::pop()
{
    node* temp;

    if (top == NULL)
    {
        cout << "\nThe stack is empty.";
    }

    temp = top;
    top = top->next;
    cout << "\nPOP Operation" << endl << "Poped value is " << temp->bracket;
    delete temp;
}

// evaluate a stack for bracket logic
void stack::evaluate()
{
    node* target = top;
    node* targetNext = target->next;
    node* temp;
    node* tempNext;

    if (target == NULL)
    {
        cout << "\nTrue" << endl;
    }

    while (target != NULL)
    {
        if (isPair(targetNext, target)) {
            temp = targetNext->next;
            tempNext = temp->next;

            cout << target->bracket << " and " << targetNext->bracket << " are deleted" << endl;

            delete target;
            delete targetNext;

            target = temp;
            targetNext = tempNext;

        } else {
            target = target->next;
            targetNext = target->next;
        }
    }

}


// Show stack
void stack::show()
{
    node* ptr1 = top;
    cout<<"\nThe stack is\n";
    while(ptr1 != NULL)
    {
        cout << ptr1->bracket << " -> ";
        ptr1 = ptr1->next;
    }
    cout << "NULL\n";
}

// Main function
int main()
{
    stack s1;

    string brackets = "[()]{}{[()()]()}";

    for(char& c : brackets) {
        s1.push(c);
    }

    s1.show();

    s1.evaluate();

    s1.show();

    return 0;
}

现在，我专注于if逻辑部分。 我更改了符号：

bool isPair(node* n2, node* n1) {

    if ((n1->bracket == '(' && n2->bracket == ')') || (n1->bracket == '[' && n2->bracket == ']') || (n1->bracket == '{' && n2->bracket == '}')) {
        return true;
    } else {
        return false;
    }
}

至：

bool isPair(node* n2, node* n1) {

    if (n1->bracket == '(' && n2->bracket == ')')
    {
        return true;
    }

    else if (n1->bracket == '[' && n2->bracket == ']')
    {
        return true;
    }

    else if (n1->bracket == '{' && n2->bracket == '}')
    {
        return true;
    }

    else
    {
        return false;
    }
}

但它没有改变任何东西（如预期的那样）。 为什么Xcode不想完全继续我的代码？

目前的输出是：

The stack is
} -> ) -> ( -> ] -> ) -> ( -> ) -> ( -> [ -> { -> } -> { -> ] -> ) -> ( -> [ -> NULL
( and ) are deleted
{ and } are deleted
(lldb) 

我知道，代码是非常noobie，我是C ++和数据结构的新手，但是，你的帮助是完全赞赏的！ 😄

Answer 1

我在你的代码中看到的问题：

问题1

当您删除target和targetNext时，您将离开悬空指针。

假设你有：

          target     targetNext
           |          |
           v          v
+----+     +----+     +----+
|    | --> |    | --> |    |
+----+     +----+     +----+

删除target和targetNext ，剩下的就是：

node with dangling pointer
|
v
+----+     +----+     +----+
|    | --> | x  | --> | x  |
+----+     +----+     +----+

您已跟踪target之前的节点，并确保将其next设置为targetNext->next 。

当你这样做时，你必须小心处理top和target是同一节点的情况。

你需要使用：

// Special case the top node.
if ( top == target )
{
   top = prev = targetNext->next;
}
else
{
   prev->next = targetNext->next;
}

问题2

删除一对匹配括号时，您需要从顶部开始检查。 否则，您永远无法匹配外部括号。

假设你以“[（）]”开头。
您删除内部匹配对“（）”。 现在你留下了“[]”。
如果您不从顶部开始，则剩下的一对将进行杠杆匹配。

删除target和targetNext后，您需要使用以下逻辑。

// Start checking from the top.
target = top;
if (target == NULL)
{
   cout << "\nTrue" << endl;
   return;
}

targetNext = target->next;
if ( targetNext == NULL )
{
   cout << "\nFalse" << endl;
   return;
}

问题3

使用防御性编程。 在设置targetNext之前，请始终检查target是否有效，即它不是NULL。 将函数顶部更改为：

node* target = top;
node* targetNext = NULL;
if ( target != NULL )
{
   targetNext = target->next;
}

在循环内添加类似的检查。

if (isPair(targetNext, target)) {
   ...
} else {
   target = target->next;
   if ( target != NULL )
   {
      targetNext = target->next;
   }
   else
   {
      targetNext = NULL;
   }
}

问题4

isPair的预期节点被切换。

当输入字符串是“[（）]”时，堆栈对象是：

] -> ) -> ( -> [ -> NULL

当target指向'）'时， targetNext指向'（`。

您检查target和targetNext是否指向匹配对的调用是：

if (isPair(targetNext, target)) {

在isPair ，您有：

bool isPair(node* n2, node* n1) {
    if ((n1->bracket == '(' && n2->bracket == ')') ...

如您所见， n1和n2被翻转。 您应该将其更改为：

bool isPair(node* n1, node* n2) {
    if ((n1->bracket == '(' && n2->bracket == ')') ...

或在调用函数时切换参数。

问题5

当支架不匹配时，您缺少输出False 。

---

清理了isPair版本并evaluate ：

bool isPair(node* n1, node* n2)
{
   return ( (n1->bracket == '(' && n2->bracket == ')') ||
            (n1->bracket == '[' && n2->bracket == ']') ||
            (n1->bracket == '{' && n2->bracket == '}'));
}

void stack::evaluate()
{
   node* target = top;
   node* prev = top;

   while ( target )
   {
      node* targetNext = target->next;
      if ( targetNext == NULL )
      {
         cout << "\nFalse" << endl;
         return;
      }

      if (isPair(targetNext, target)) {

         cout << target->bracket << " and " << targetNext->bracket << " are deleted" << endl;

         // Special case the top node.
         if ( top == target )
         {
            top = prev = targetNext->next;
         }
         else
         {
            prev->next = targetNext->next;
         }

         delete target;
         delete targetNext;

         // Intermediate output for troubleshooting.
         // this->show();

         // Start checking from the top.
         target = top;
      }
      else
      {
         prev = target;
         target = target->next;
      }
   }

   cout << "\nTrue" << endl;
   return;
}