二叉树的遍历--七种方式之Python实现

class Node(object):
    def __init__(self, data):
        self.elem = data
        self.lchild = None
        self.rchild = None

class Tree(object):
    def __init__(self):
        self.root = None
    def add(self, elem):
        '''按照从上到下从左到右的顺序进行添加，
        跟层次遍历的顺序保持一致
        需要使用队列执行先入后出操作'''
        node = Node(elem)
        if self.root is None:
            self.root = node
            return
        queue = [self.root]
        while queue:
            curNode = queue.pop(0)
            if curNode.lchild is None:
                curNode.lchild = node
                return
            else:
                queue.append(curNode.lchild)
            if curNode.rchild is None:
                curNode.rchild = node
                return
            else:
                queue.append(curNode.rchild)
    def breadth_travel(self):
        if self.root is None:
            print('no data, please add...')
            return
        queue = [self.root]
        '''[None] 和 []是不一样的'''
        while queue:
            '''队列只要不为空，就一直从队首弹出元素进行判断'''
            curNode = queue.pop(0)
            print (curNode.elem, end=' ')
            if curNode.lchild is not None:
                queue.append(curNode.lchild)
            if curNode.rchild is not None:
                queue.append(curNode.rchild)
    def preorder(self, node):
        '''递归方式'''
        if node is None:
            return
        print(node.elem, end=' ')
        self.preorder(node.lchild)
        self.preorder(node.rchild)
    def midorder(self, node):
        '''递归'''
        if node is None:
            return
        self.midorder(node.lchild)
        print(node.elem, end=' ')
        self.midorder(node.rchild)
    def postorder(self, node):
        '''递归'''
        if node is None:
            return
        self.postorder(node.lchild)
        self.postorder(node.rchild)
        print(node.elem, end=' ')
        
    '''只要包括中序在内的两种遍历结果就能重构这棵二叉树
    中序可以把左右节点分开'''
    
    def preorder_iter(self, root):
        '''迭代，利用栈实现'''
        if self.root is None:
            return
        '''  方法一
        stack = [root]
        while stack:
            curNode = stack.pop()
            print(curNode.elem,end=' ')
            if curNode.rchild:
                stack.append(curNode.rchild)
            if curNode.lchild:
                stack.append(curNode.lchild)
                ''' 
        #方法二
        stack = []
        curNode = root
        while stack or curNode:
            while curNode:
                print(curNode.elem, end=' ')
                stack.append(curNode)
                curNode = curNode.lchild
            curNode = stack.pop()
            curNode = curNode.rchild
        
        
    
    def midorder_iter(self, root):
        if self.root is None:
            return
        stack =[]
        curNode = root
        while stack or curNode:
            while curNode:
                stack.append(curNode)
                curNode = curNode.lchild
            curNode = stack.pop()
            print(curNode.elem, end=' ')
            curNode = curNode.rchild
            
    def postorder_iter(self, root):
        if self.root is None:
            return
        stack = []
        curNode = root
        inverse_stack = []
        while stack or curNode:
            while curNode:
                stack.append(curNode)
                inverse_stack.append(curNode.elem)
                curNode = curNode.rchild
            curNode = stack.pop()
            curNode = curNode.lchild
        for x in inverse_stack[::-1]:
            print(x, end=" ")
    
                    
            
    
        
    
if __name__ == '__main__':
    tree = Tree()
    for i in range(1,10):
        tree.add(i)
    print('breath_travel:\n')
    tree.breadth_travel()
    print('\n')
    print('preorder:\n')
    tree.preorder(tree.root)
    print('\n')
    print('midorder:\n')
    tree.midorder(tree.root)
    print('\n')
    print('postorder:\n')
    tree.postorder(tree.root)
    print('\n')
    print('preorder_iter:\n')
    tree.preorder_iter(tree.root)
    print('\n')
    print('midorder_iter:\n')
    tree.midorder_iter(tree.root)
    print('\n')
    print('postorder_iter:\n')
    tree.postorder_iter(tree.root)

输出：

breath_travel:

1 2 3 4 5 6 7 8 9 

preorder:

1 2 4 8 9 5 3 6 7 

midorder:

8 4 9 2 5 1 6 3 7 

postorder:

8 9 4 5 2 6 7 3 1 

preorder_iter:

1 2 4 8 9 5 3 6 7 

midorder_iter:

8 4 9 2 5 1 6 3 7 

postorder_iter:

8 9 4 5 2 6 7 3 1