1- # https://en.wikipedia.org/wiki/Tree_traversal
21from __future__ import annotations
32
43from collections import deque
5- from collections .abc import Sequence
4+ from collections .abc import Generator , Sequence
65from dataclasses import dataclass
76from typing import Any
87
98
9+ # https://en.wikipedia.org/wiki/Tree_traversal
1010@dataclass
1111class Node :
1212 data : int
@@ -31,44 +31,56 @@ def make_tree() -> Node | None:
3131 return tree
3232
3333
34- def preorder (root : Node | None ) -> list [int ]:
34+ def preorder (root : Node | None ) -> Generator [int , None , None ]:
3535 """
3636 Pre-order traversal visits root node, left subtree, right subtree.
37- >>> preorder(make_tree())
37+ >>> list( preorder(make_tree() ))
3838 [1, 2, 4, 5, 3]
3939 """
40- return [root .data , * preorder (root .left ), * preorder (root .right )] if root else []
40+ if not root :
41+ return
42+ yield root .data
43+ yield from preorder (root .left )
44+ yield from preorder (root .right )
4145
4246
43- def postorder (root : Node | None ) -> list [int ]:
47+ def postorder (root : Node | None ) -> Generator [int , None , None ]:
4448 """
4549 Post-order traversal visits left subtree, right subtree, root node.
46- >>> postorder(make_tree())
50+ >>> list( postorder(make_tree() ))
4751 [4, 5, 2, 3, 1]
4852 """
49- return postorder (root .left ) + postorder (root .right ) + [root .data ] if root else []
53+ if not root :
54+ return
55+ yield from postorder (root .left )
56+ yield from postorder (root .right )
57+ yield root .data
5058
5159
52- def inorder (root : Node | None ) -> list [int ]:
60+ def inorder (root : Node | None ) -> Generator [int , None , None ]:
5361 """
5462 In-order traversal visits left subtree, root node, right subtree.
55- >>> inorder(make_tree())
63+ >>> list( inorder(make_tree() ))
5664 [4, 2, 5, 1, 3]
5765 """
58- return [* inorder (root .left ), root .data , * inorder (root .right )] if root else []
66+ if not root :
67+ return
68+ yield from inorder (root .left )
69+ yield root .data
70+ yield from inorder (root .right )
5971
6072
61- def reverse_inorder (root : Node | None ) -> list [int ]:
73+ def reverse_inorder (root : Node | None ) -> Generator [int , None , None ]:
6274 """
6375 Reverse in-order traversal visits right subtree, root node, left subtree.
64- >>> reverse_inorder(make_tree())
76+ >>> list( reverse_inorder(make_tree() ))
6577 [3, 1, 5, 2, 4]
6678 """
67- return (
68- [ * reverse_inorder ( root . right ), root . data , * reverse_inorder ( root . left )]
69- if root
70- else []
71- )
79+ if not root :
80+ return
81+ yield from reverse_inorder ( root . right )
82+ yield root . data
83+ yield from reverse_inorder ( root . left )
7284
7385
7486def height (root : Node | None ) -> int :
@@ -178,10 +190,10 @@ def main() -> None: # Main function for testing.
178190 root = make_tree ()
179191
180192 # All Traversals of the binary are as follows:
181- print (f"In-order Traversal: { inorder (root )} )
182- print (f"Reverse In-order Traversal: { reverse_inorder (root )} )
183- print (f"Pre-order Traversal: { preorder (root )} )
184- print (f"Post-order Traversal: { postorder (root )} , "\n " )
193+ print (f"In-order Traversal: { list ( inorder (root ) )} )
194+ print (f"Reverse In-order Traversal: { list ( reverse_inorder (root ) )} )
195+ print (f"Pre-order Traversal: { list ( preorder (root ) )} )
196+ print (f"Post-order Traversal: { list ( postorder (root ) )} , "\n " )
185197
186198 print (f"Height of Tree: { height (root )} , "\n " )
187199
0 commit comments