如何以广度优先顺序实现二叉树的迭代器

如何解决如何以广度优先顺序实现二叉树的迭代器

我有这个二叉树，但我不知道如何为此实现迭代器。 这是代码

class node:
    """
    Defines a node in the binary tree
    """
    def __init__( self,value,left=None,right=None ):
        """
        """
        self.value = value
        self.left = left
        self.right = right
        
    def __eq__(self,other):
        if self.value == other.value and self.right == other.right and self.left == other.left:
            return True
        else:
            return False
    
       
class iterator:
    """
    Iterator for a binary_tree instance
    """
    def __init__(self,node):
        self.right = node.right
        self.left = node.left
        
    
    def __iter__(self):
        return self

    def __next__(self):
        if 

        else:
            raise stopiteration

class binary_tree:
    """
    Implements a binary tree
    """
    def __init__( self ):
        """
        """
        self.root = None
        self.size = 0
        
    def __len__(self):
        return self.size
    
    def add( self,value ):
        """
        """
        if self.root is None:
            self.root = node(value)
        
        else:
            self._add(value,self.root)
    
    def _add(self,node):
        """
        """
        if value < node.value:
            if node.left is not None:
                self._add(value,node.left)
            else:
                node.left = node(value)
        
        else:
            if node.right is not None:
                self._add(value,node.right)
            else:
                node.right = node(value)
        

    def __iter__( self ):
        """
        """
        return iterator(self.root)

我想通过的是：

b = binary_tree()

for v in [4,2,4,8,1,5]:
    #
    b.insert( v )

given = sorted( [v for v in b] )
correct_answer = [1,5,8]

assert given == correct_answer

我不知道或迷失了如何实现广度优先顺序，而且我不想使用 yield 或任何包或模块。 为这种类型的二叉树实现迭代器的最佳方法是什么？