試圖平衡括號但不明白我的代碼有什么問題

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_list = [ '{', '[', '(' ]

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

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

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

所以他們必須匹配， Opens(1) = Closes(3), Opens(2) = Closes(2) and 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)