二叉树的先根、中根、后根遍历 递归非递归python实现

'''
先根、中根、后根递归遍历二叉树
'''
 
class Node:
    
    def __init__(self, data=None, left=None, right=None):
        self.data = data
        self.left = left
        self.right = right
        
class BinaryTreeOrderRecursive:
    ''' 递归遍历 '''
    def __init__(self, root=None):
        self.root = root
        
    def isEmpty(self):
        return self.root == None
    
    def preOrder(self, node):
        if node == None:
            return 
        # 先打印根节点，再打印左节点，后打印右节点
        print(node.data, end=' ')
        self.preOrder(node.left)
        self.preOrder(node.right)
        
    def inOrder(self, node):
        if node == None:
            return 
        # 先打印左结点，再打印根结点，后打印右结点
        self.inOrder(node.left)
        print(node.data, end=' ')
        self.inOrder(node.right)
        
    def postOrder(self, node):
        if node == None:
            return
        # 先打印左结点，再打印右结点，后打印根结点
        self.postOrder(node.left)
        self.postOrder(node.right)
        print(node.data, end=' ')
 

class BinaryTreeOrderUnRecursive:       
    ''' 非递归遍历 '''
    def __init__(self, root=None):
        self.root = root
        
    def isEmpty(self):
        return self.root == None
    
    def preOrder(self, node):
        stack = [node]
        while len(stack) > 0:
            print(node.data, end=' ')
            if node.right != None:
                stack.append(node.right)
            if node.left != None:
                stack.append(node.left)
            node = stack.pop()    
            
    def inOrder(self, node):
        stack = []
        pos = node
        while pos != None or len(stack) > 0:
            if pos != None:
                stack.append(pos)
                pos = pos.left
            else:
                pos = stack.pop()
                print(pos.data, end=' ')
                pos = pos.right
                
    def postOrder(self, node):
        '''
        使用两个栈结构
        第一个栈进栈顺序：左节点->右节点->跟节点
        第一个栈弹出顺序： 跟节点->右节点->左节点(先序遍历栈弹出顺序：跟->左->右)
        第二个栈存储为第一个栈的每个弹出依次进栈
        最后第二个栈依次出栈
        '''
        stack = [node]
        stack2 = []
        while len(stack) > 0:
            node = stack.pop()
            stack2.append(node)
            if node.left is not None:
                stack.append(node.left)
            if node.right is not None:
                stack.append(node.right)
        while len(stack2) > 0:
            print(stack2.pop().data, end=' ')
    
            
    def layerOrder(self, node):
        ''' 层次遍历'''
        import queue
        if node == None:
            return 
        que = queue.Queue()  # 创建一个先进先出的队列
        que.put(node)
        while not que.empty():
            out = que.get()   # 弹出第一个元素
            print(out.data)
            if out.left:  # 若该节点存在左子节点,则加入队列（先push左节点）
                que.put(out.left)
            if out.right:   # 若该节点存在右子节点,则加入队列（再push右节点）
                que.put(out.right)
        
    def treeNodeNum(self, node):
        # 求二叉树节点个数
        if node == None:
            return 0
        num = self.treeNodeNum(node.left)
        num += self.treeNodeNum(node.right)
        return num+1
            
    def bTreeDepth(self, node):
        # 二叉树的最大深度
        if node is None:
            return 0
        ldepth = self.bTreeDepth(node.left)
        rdepth = self.bTreeDepth(node.right)
        return (max(ldepth, rdepth) + 1)
                
    
    
n1 = Node(data="D")
n2 = Node(data="E")
n3 = Node(data="F")
n4 = Node(data="B", left=n1, right=n2)
n5 = Node(data="C", left=n3, right=None)
n6 = Node(data="A", left=n4, right=n5)
root = Node(data='M', left=None, right=n6)

bt = BinaryTreeOrderRecursive(root)
print('递归先序遍历')
bt.preOrder(bt.root)
print('\n')
print('递归中序遍历')
bt.inOrder(bt.root)
print('\n')
print('递归后序遍历')
bt.postOrder(bt.root)
print('\n')

bt = BinaryTreeOrderUnRecursive(root)
print('非递归先序遍历')
bt.preOrder(bt.root)
print('\n')
print('非递归中序遍历')
bt.inOrder(bt.root)
print('\n')
print('非递归后序遍历')
bt.postOrder(bt.root)