在 Python 中实现 Stack 的 BFS 二叉树答案

【问题标题】：BFS binary tree that implements Stack in Python在 Python 中实现 Stack 的 BFS 二叉树
【发布时间】：2021-04-16 23:35:24
【问题描述】：

我正在寻找使用堆栈（不是队列！）在 Python 中实现二叉树的 BFS（广度优先搜索）。

class Stack:
    def __init__(self):
        self.data = []
        
    def Empty(self):
        return self.data == []

    def Push(self, x):
        self.data.append(x)

    def Pop(self):
        return self.data.pop()

    def Peek(self):
        return self.data[len(self.data)-1]

    def Size(self):
        return len(self.data)


class Node:
    def __init__(self, data, left, right):
        self.data = data
        self.l_node = left
        self.r_node = right


class Tree:
    def __init__(self):
        self.root= None

    def bfs_stack(self, node):
        pass


t = Tree()
t.root = Node("1")
t.root.l_node = Node("2")
t.root.l_node.l_node = Node("4")
t.root.l_node.r_node = Node("5")
t.root.l_node.r_node.l_node = Node("8")
t.root.r_node = Node("3")
t.root.r_node.l_node = Node("6")
t.root.r_node.r_node = Node("7")
t.root.r_node.r_node.l_node = Node("9")
t.root.r_node.r_node.l_node.l_node = Node("11")
t.root.r_node.r_node.r_node = Node("10")

我创建了 Stack() 类来使用。我尝试将递归和堆栈推送结合起来，但我没有想法。

队列实现非常简单，但对我来说拥有一个 Stack() 实现很重要。

【问题讨论】：

标签： python stack binary-tree breadth-first-search tree-traversal

【解决方案1】：

从算法上讲，BFS 与队列操作相关联，而 DFS 与堆栈操作相关联。

如果你只有栈，你可以用两个栈组成一个队列。

堆栈实现 FILO（先进后出）顺序，而队列实现 FIFO（先进先出）。

如果您将三个数字 1,2,3 放在一个堆栈中，然后将它们拉出，您会得到 3,2,1。

如果你对队列做同样的事情，它们会以 1、2、3 的形式出现。

现在假设我们将 1,2,3 放入堆栈 A，将它们作为 3,2,1 取出，然后将它们放入堆栈 B。将它们从堆栈 B 中取出将产生 1,2,3，即意味着通过两个堆栈类似于通过队列。

现在，如果您拥有整个序列并一次输入所有内容然后将其全部取出，则此参数本身就有效。但对于 BFS/DFS 搜索，情况并非如此，您输入一些内容，然后在输入更多内容之前将其取出。

如果堆栈 B 完全为空，您仍然可以通过仅将堆栈 A 中的内容移动到堆栈 B 来使 BFS 工作，然后将整个堆栈 A 转移到 B 中。B 为空确保将内容放入堆栈B 在将东西收集到堆栈 A 之前全部处理。将整个 A 放入 B 可确保与中心节点相同距离的所有节点在任何给定时间都保持在同一堆栈（A 或 B）中。每次从堆栈 A 到 B 的内容传输都代表在距起始节点特定距离处完成了 BFS 级别的处理，并且保证内层在外层之前处理，这就是 BFS。

stack_a = Stack()
stack_b = Stack()

stack_b.Push(t.root)
while len(stack_a)+len(stack_b)>0:
    if len(stack_b) >0:
        current_node = stack_b.Pop()
    else:
        while len(stack_a)> 0:
            stack_b.Push(stack_a.Pop())
        current_node = stack_b.Pop()
    process(current_node) # this gets called on nodes in BFS order
    for neighbor in [current_node.l_node, current_node.r_node]:
        stack_a.Push(neighbor)
        #can generalize this to non-binary graphs by iterating through all unvisited neighbors
        #for cyclical graphs, must track processed nodes to ensure nodes don't get processed more than once

【讨论】：