Traversal example of binary tree of Python data structure _python

Traversal scenarios
From the recursive definition of the two-fork tree, a non-empty two-tree consists of three basic parts, the root node and the left and right subtree. Therefore, at any given node, you can perform three actions in a certain order:
1). Access node itself (N)
2). Zuozi (L) traversing the node
3). Traverse the right subtree of the node (R)

There is Order:
NLR, LNR, LRN

Traversal of the named

Named according to where the Access node operation occurred:
NLR: Pre-sequence traversal (Preordertraversal also called (first-order traversal))--Accessing a node occurs before traversing its left and right subtree.
LNR: In-sequence traversal (inordertraversal)--the operation of accessing a node occurs in the traversal of its left and right subtree (inter).
LRN: Sequence Traversal (postordertraversal)--access to a node occurs after traversing its left and right subtree.

Note: Since the node being accessed must be the root of a subtree, then n (node), L (left Subtlee), and R (right subtree) can also be interpreted as the root, root, and Zoki tree. NLR, LNR, and LRN are also known as first-root traversal, root traversal, and back-root traversal.

Traversal algorithm

1). Recursive algorithm definition for first-order traversal:
If the binary tree is not empty, then do the following:
A. Accessing root nodes
B. Traversal Zuozi
C. Traversing the right subtree

2). Recursive algorithm definition for sequence traversal:
If the binary tree is not empty, then do the following:
A. Traversal Zuozi
B. Accessing root nodes
C. Traversing the right subtree

3). Sequence traversal recursive algorithm definition:
If the binary tree is not empty, then do the following:
A. Traversal Zuozi
B. Traversing the right subtree
C. Access to root nodes

Recursive traversal of one or two-fork tree:

Copy Code code as follows:

#-*-Coding:utf-8-*-

Class TreeNode (object):

def __init__ (self, left=0, right=0, data=0):
Self.left = Left
Self.right = Right
Self.data = Data


Class Btree (object):

def __init__ (self, root=0):
Self.root = root

def is_empty (self):
If Self.root is 0:
Return True
Else
Return False

def preorder (self, TreeNode):
' Pre-order (PRE-ORDER,NLR) traversal '
If TreeNode is 0:
Return
Print Treenode.data
Self.preorder (Treenode.left)
Self.preorder (Treenode.right)

def inorder (Self, TreeNode):
' Middle order (IN-ORDER,LNR '
If TreeNode is 0:
Return
Self.inorder (Treenode.left)
Print Treenode.data
Self.inorder (Treenode.right)

def postorder (Self, TreeNode):
' Subsequent (POST-ORDER,LRN) traversal '
If TreeNode is 0:
Return
Self.postorder (Treenode.left)
Self.postorder (Treenode.right)
Print Treenode.data


Node1 = TreeNode (data=1)
Node2 = TreeNode (Node1, 0, 2)
Node3 = TreeNode (data=3)
Node4 = TreeNode (data=4)
NODE5 = TreeNode (Node3, NODE4, 5)
Node6 = TreeNode (Node2, NODE5, 6)
Node7 = TreeNode (node6, 0, 7)
Node8 = TreeNode (data=8)
Root = TreeNode (Node7, node8, ' root ')

BT = Btree (Root)

Print U ' '

#生成的二叉树

# ------------------------
# root
# 7 8
# 6
# 2 5
# 1 3 4
#
# -------------------------

'''
print ' Pre-order (PRE-ORDER,NLR) traversal: \ n '
Bt.preorder (Bt.root)

print ' in sequence (IN-ORDER,LNR) traversal: \ n '
Bt.inorder (Bt.root)

print ' sequence (POST-ORDER,LRN) traversal: \ n '
Bt.postorder (Bt.root)

Ii.. Non-recursive traversal of two-fork tree

The following is implemented in a non recursive manner. The main use of stack and queue maintenance some data nodes:

Copy Code code as follows:

#-*-Coding:utf-8-*-


Class TreeNode (object):

def __init__ (self, left=0, right=0, data=0):
Self.left = Left
Self.right = Right
Self.data = Data


Class Btree (object):

def __init__ (self, root=0):
Self.root = root

def is_empty (self):
If Self.root is 0:
Return True
Else
Return False

def preorder (self, TreeNode):
' Pre-order (PRE-ORDER,NLR) traversal '
stack = []
While TreeNode or stack:
If TreeNode is not 0:
Print Treenode.data
Stack.append (TreeNode)
TreeNode = Treenode.left
Else
TreeNode = Stack.pop ()
TreeNode = Treenode.right

def inorder (Self, TreeNode):
' Central sequence (IN-ORDER,LNR) traversal '
stack = []
While TreeNode or stack:
If TreeNode:
Stack.append (TreeNode)
TreeNode = Treenode.left
Else
TreeNode = Stack.pop ()
Print Treenode.data
TreeNode = Treenode.right

# def postorder (self, TreeNode):
# stack = []
# PRE = 0
# while TreeNode or stack:
# if TreeNode:
# Stack.append (TreeNode)
# treenode = Treenode.left
# elif Stack[-1].right!= pre:
# treenode = Stack[-1].right
# PRE = 0
# Else:
# PRE = Stack.pop ()
# Print Pre.data

def postorder (Self, TreeNode):
' Subsequent (POST-ORDER,LRN) traversal '
stack = []
Queue = []
Queue.append (TreeNode)
While queue:
TreeNode = Queue.pop ()
If Treenode.left:
Queue.append (Treenode.left)
If Treenode.right:
Queue.append (Treenode.right)
Stack.append (TreeNode)
While stack:
Print Stack.pop (). Data

def levelorder (Self, TreeNode):
From collections Import Deque
If not TreeNode:
Return
Q = deque ([TreeNode])
While Q:
TreeNode = Q.popleft ()
Print Treenode.data
If Treenode.left:
Q.append (Treenode.left)
If Treenode.right:
Q.append (Treenode.right)


Node1 = TreeNode (data=1)
Node2 = TreeNode (Node1, 0, 2)
Node3 = TreeNode (data=3)
Node4 = TreeNode (data=4)
NODE5 = TreeNode (Node3, NODE4, 5)
Node6 = TreeNode (Node2, NODE5, 6)
Node7 = TreeNode (node6, 0, 7)
Node8 = TreeNode (data=8)
Root = TreeNode (Node7, node8, ' root ')


BT = Btree (Root)

Print U ' '

#生成的二叉树

# ------------------------
# root
# 7 8
# 6
# 2 5
# 1 3 4
#
# -------------------------

'''
print ' Pre-order (PRE-ORDER,NLR) traversal: \ n '
Bt.preorder (Bt.root)

print ' in sequence (IN-ORDER,LNR) traversal: \ n '
Bt.inorder (Bt.root)

print ' sequence (POST-ORDER,LRN) traversal: \ n '
Bt.postorder (Bt.root)

print ' sequence (LEVEL-ORDER,LRN) traversal: \ n '
Bt.levelorder (Bt.root)