Question

我试图通过使用递归来生成一个平衡的括号解析器并生成一个树。

例如，如果你传入'()()'，树就会像这样构建

第1步

  B
  |
empty

第2步

       B 
   /   |   \   \
  (  empty  )   B
                |
              empty

第3步

      B 
  /   |   \    \
 (  empty  )    B
             /  |  \   \
            ( empty )   B
                        |
                      empty

现在，我的代码“有点”适用于像'（）（）'这样的合法输入，但它应该为'（））之类的东西给我假（'。它不返回False。可以我得到了帮助吗？

class Node:
    def __init__(self, label):
        self.label = label
        self.leftmostChild = None
        self.rightSibling = None


def makeNode0(x):
    root = Node(None)
    root.label = x

    return root


def makeNode1(x, t):
    root = makeNode0(x)
    root.leftmostChild = t

    return root


def makeNode4(x, t1, t2, t3, t4):
    root = makeNode1(x, t1)
    t1.rightSibling = t2
    t2.rightSibling = t3
    t3.rightSibling = t4

    return root


nextTerminal = "())("


def B(index):
    firstB = Node(None)
    secondB = Node(None)

    if index != len(nextTerminal):
        if nextTerminal[index] == '(':
            index += 1
            firstB = B(index)

            if firstB is not False and nextTerminal[index] == ')':
                index += 1
                secondB = B(index)

                if secondB is False:
                    return False
                else:
                    return makeNode4('B', makeNode0('('), firstB, makeNode0(')'), secondB)
            else:
                return False
        else:
            return makeNode1('B', makeNode0('emp'))


b = B(0)

Answer 1

我将在这里概述第二种方法，希望它能让您深入了解当前程序无法正常工作的原因。坦率地说，我不确定发生了什么 - 我最初认为每个正确的兄弟都表示了一个额外的括号声明，但看起来树的结构是硬编码的，无论括号如何。我的建议是从下面的解决方案开始，然后按照自己的方式创建这些树。

跟踪变量depth。
对于每个开始括号，将depth增加1。
对于每个结束括号，将depth递减1.如果depth为负数，我们会很快遇到结束括号 - 返回false。

处理完所有括号后，检查depth是否为0.否则，我们的括号开头太多了。

平衡括号解析器Python

1 个答案: