python：使用栈技术来接解决 文本中括号配对问题

1. 栈的顺序表实现

# 【栈的顺序表实现】
#  把list当做栈使用，完全可以满足应用的需要。但这样建立的还是list对象，提供了list类型的所有操作
# 特别是提供了一大批栈结构不应该支持的操作，威胁栈的使用安全性
# 为了概念更清晰、实现安全、操作名也更容易理解，可基于顺序表定义一个栈类。

# 为操作失败的处理定义一个异常类
class  StackUnderflow(ValueError): #  栈下溢（空栈访问）
    pass                           #  未定义任何新属性

class sStack:                          #  基于顺序表实现的栈类
    def __init__(self):                #  用list对象_elems存储栈中元素
        self._elems = []               #   所有栈操作都映射到list操作

    def is_empty(self):               #   判断是否为空栈，若为空返回True,否则返回False
        return self._elems == []

    def top(self):                    #  访问栈顶元素
        if self._elems == []:
            raise StackUnderflow("In sStack.top")     #  异常  用于帮助检查程序错误
        return sefl._elems[-1]

    def push(self,elem):              #  压入元素
        self._elems.append(elem)

    def pop(self):                    #  弹出元素
        if self._elems == []:
            raise StackUnderflow("In sStack.pop")   #  异常  传递有用的信息状态
        return self._elems.pop()

2. 检查文中括号配对原则：扫描正文过程中，遇到的闭括号应该与此前遇到的且尚未获得匹配的开括号配对，若不匹配，则匹配失败。使用栈技术的原因：（1）文中括号出现的括号种类和数量不能确定，需用缓冲结构。（2）括号需要逐对匹配，当前闭括号应该与前面最近的尚未配对的开括号匹配，存储的开括号的使用原则是 后存者先使用，符合LIFO。

def check_parens(text):                       #  括号配对检查函数

    parens = "()[]{}"                         #  所有括号字符
    open_parens = "([{"                       #  开括号字符
    opposite = {")":"(", "]":"[", "}":"{"}   #  表示配对关系 的字典

    '''
    def parentheses(text):   #  生成器 -- 每次调用返回 text 里的下一括号及其位置
        i, text_len = 0, len(text)
        while True:
            while i < text_len and text[i] not in parens:
                i += 1
            if i >= text_len:
                return
            yield text[i],i
            i += 1
    '''

    def parentheses(text):  # 生成器   返回括号 以及在文本中的位置
        i, text_len = 0, len(text)
        while i < text_len:
            if text[i] in parens:
                yield text[i], i
            i += 1

    st = sStack()
    for pr ,i in parentheses(text):
        if pr in open_parens: # 将 开括号 存入栈
            st.push(pr)
        elif st.pop() != opposite[pr]:  # 比较最内侧的 括号 是否配对，不配对退出循环
            print("Unmatching is found at", i, "for", pr)
            return False
        #else:  这是一次括号配对成功，什么也不做，继续

    print("All parentheses are correctly matxhed.")
    return True

text = "{{([people])}}"
print(check_parens(text))  #  True

3.另一种方法：

text = "{[(po)][(pe)][(ple)]}"
def solve(text):
    kaikuohao = "{[("
    bikuohao = "}])"
    kuohaozidian = {"}":"{", "]":"[", ")":"(" }
    aa1 = sStack()           #  建立栈对象

    for i in text:              #  遍历文本每一个元素
        if i in kaikuohao:      #  将元素中的开括号入栈
            aa1.push(i)
            continue
        if i in bikuohao:      #   若是闭括号，将之与出栈的元素比较，若不是一对，返回错误
            if aa1.pop() is not kuohaozidian[i]:
                return False
    return True               #   全部匹配成功

print(solve(text))