使用中序遍历打印二叉树

Question

I want to print a Binary Tree using Inorder Traversal, I have these functions and I'm wondering how I would go about writing a function to use them to print the binary tree. Any help massively appreciated.

def inorder(self):
    if not self.is_empty():
      for p in self._subtree_inorder(self.root()):
        yield p

  def _subtree_inorder(self, p):
    if self.left(p) is not None:
      for other in self._subtree_inorder(self.left(p)):
        yield other
    yield p
    if self.right(p) is not None:
      for other in self._subtree_inorder(self.right(p)):
        yield other

  def positions(self):
    return self.inorder()

Answer 1

Here two possible solutions in Python, given the following binary search tree.

       20
      /  \
    10    30
         /  \
       35    40
        \
         37

Recursive traversal

The recursion ends whenever a node is null. Call inorder_rec() first for the left subtree, then print the value of the current node, then print it for the right subtree.

Traversal using generator

The approach is more or less the same (not surprisingly, as the algorithm is the same). We first need to yield all the result from the left subtree, then we yield the value of the current node and last but not least we yield the keys from the right subtree.

All together

class Node:
    def __init__(self, key):
        self.left = None
        self.right = None
        self.key = key


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

    def insert(self, key):
        self.root = self.insert_rec(self.root, key)

    def insert_rec(self, node, key):
        if node is None:
            return Node(key)
        if key == node.key:
            print(f"Key {key} already present! Ignoring value!")
            return node
        if key <= node.key:
            node.left = self.insert_rec(node.left, key)
        else:
            node.right = self.insert_rec(node.right, key)
        return node

    def inorder(self):
        self.inorder_rec(self.root)

    def inorder_rec(self, node):
        # end of recursion if current node is None
        if node is None:
            return
        # indorder means: left subtree, then own value, then right subtree
        self.inorder_rec(node.left)
        print(node.key)
        self.inorder_rec(node.right)

    def inorder_with_generator(self):
        # yield from inorder_genreator()
        yield from self.inorder_generator(self.root)

    def inorder_generator(self, node):
        # nothing to yield if node is None
        if node is not None:
            for node_data in self.inorder_generator(node.left):
                yield node_data
            yield node.key
            for node_data in self.inorder_generator(node.right):
                yield node_data


tree = Bst()
tree.insert(20)
tree.insert(10)
tree.insert(30)
tree.insert(40)
tree.insert(35)
tree.insert(37)

tree.inorder()
print(list(tree.inorder_with_generator()))

Expected output:

10
20
30
35
37
40
[10, 20, 30, 35, 37, 40]

To avoid having to provide the root node as an argument every time I have added two functions which always start the traversal at the root node without the need to supply any parameters.