试图平衡括号但不明白我的代码有什么问题

Question

我正在尝试使用 Stacks 平衡 Python 上的括号。我一直试图找出问题所在，但我不明白。这是我写的代码：

class Stack:

def __init__(self):
    self.opens = []
    self.closes = []

def empty_opens(self):
    return self.opens == []

def empty_closes(self):
    return self.closes == []

def add_opens(self, item):
    return self.opens.append(item)

def add_closes(self, item):
    return self.closes.append(item)

def is_empty_opens(self):
    return len(self.opens) == 0

def remove_opens(self):
    if not self.is_empty_opens():
        return self.opens.pop(0)

def is_empty_closes(self):
    return len(self.closes) == 0

def remove_closes(self):
    if not self.is_empty_closes():
        return self.closes.pop()


def checker(string):
open = "([{"
close = ")]}"
p = Stack()
for i in string:
    if i == "(" or i == "[" or i == "{":
        p.add_opens(i)
    elif i == ")" or i == "]" or i == "}":
        p.add_closes(i)
if len(p.opens) != len(p.closes):
    return False
else:
    for a in p.opens:
        for b in reversed(p.closes):
            if open.index(a) == close.index(b):
                p.remove_opens()
                p.remove_closes()
if len(p.opens) == 0 and len(p.closes) == 0:
    return True
else:
    return False

代码总体上可以工作，但似乎没有删除“for”循环的最后一个值。我在“for”循环之后添加了一个打印来尝试弄清楚，这就是我得到的：

    ...
    else:
    for a in p.opens:
        for b in reversed(p.closes):
            if open.index(a) == close.index(b):
                p.remove_opens()
                p.remove_closes()
    print(p.opens)
    print(p.closes)
if len(p.opens) == 1 and len(p.closes) == 1:
   ...

Python Console:

checker("{[()]}")
['(']
[')']
False

checker("{[(]]}")
['[', '(']
[']', ']']
False

我也尝试更改代码，而不是使用 .index() 我尝试使用 range(len())，但它再次不起作用：

    ...
    else:
    for a in range(len(p.opens)):
        for b in reversed(range(len(p.closes))):
            if a == b:
                p.remove_opens()
                p.remove_closes()
    print(p.opens)
    print(p.closes)
if len(p.opens) == 0 and len(p.closes) == 0:
   ...

  Python Console:

  checker("{[()]}")
  ['(']
  [')']
  False

  checker("{[(]]}")
  ['(']
  [']']
  False

这可能是一个基本错误，但我正在慢慢失去理智，所以我问是否有人可以提供帮助。

代码注释：

我试图在我的代码中做的是通过一个类创建 2 个列表，一个用于左括号："(、[、{"，另一个用于右括号："), ], }".

该类具有从列表中添加或删除的简单 Stack 方法。

关于代码本身，我首先要做的是将括号中的字符与不是括号的字符分开。如果代码找到一个打开的括号，它会添加到 "opens" 列表中，如果它是关闭的，它会添加到 "closes" 列表中。

然后它会检查每个列表中有多少项目，如果它们不相同，则立即表示它们不平衡。

现在是棘手的部分。如果打开和关闭的括号数量相同，我希望代码检查每一个。据我了解，为了平衡括号，列表 "opens" 中的第一个左括号需要等于 "closes" 列表中的最后一个右括号.

例如：

输入： { [ ( ) ] }

opens_list = [ '{', '[', '(' ]

'{' = 1, '[' = 2, '(' = 3

closes_list = [')', ']', '}' ]

')' = 1, '[' = 2, '{' = 3

所以它们必须匹配，Opens(1) = Closes(3), Opens(2) = Closes(2) 和 Opens(3) = Closes(3)强>

基于此，我所做的是反转关闭列表，以便每个索引都必须对应。在我写的代码的开头：

def checker(string):
 open = "([{"
 close = ")]}"
 ...

所以我要做的是取 opens_list 中的第一个字符 "{"，检查它在 "open variable" 中的索引，它具有第三个索引，并且对 closes 列表执行相同操作。

如果它们具有相同的索引，则会删除它们。最后，如果两个列表都没有任何元素，那么它是平衡的。

这有点乱，英语不是我的第一语言，我不知道 python 中所有正确的概念，但我希望它是可以理解的。老实说，我只是想知道出了什么问题，所以我以后不会重复同样的错误。如果有人能理解这一点并提供帮助，我将不胜感激。

Answer 1

使用堆栈检查匹配的分隔符只需要 3 个基本操作：

1. 如果字符是起始分隔符，则将其添加到堆栈中
2. 如果字符是结束分隔符，则弹出堆栈并查看它是否与结束字符匹配。
3. 在输入耗尽时检查堆栈是否为空。

没有真正需要专门的Stack 类；这三个操作都可以使用裸列表轻松实现。

def checker(string):
    match = dict(["()", "{}", "[]"])  # Mapping of opening delimiter to its closing partner
    st = []  # Initially empty stack
    for c in string:
        if c in match:  # Push an opening delimiter
            st.append(c)
        elif c in match.values():
            # Try to pop the most recent opening delimiter;
            # return False if that fails or it doesn't match the closing delimiter
            if not st or match[st.pop()] != c:
                return False

    # Check if there were any unclosed delimiters
    return (not st)