Python实现前、中、后、层序遍历

二叉树前中后序遍历

如图所示二叉树：
前序遍历：5 3 1 4 8 6 9（先根后子，子先左再右）
中序遍历：1 3 4 5 6 8 9（从左往右）
后序遍历：1 4 3 6 9 8 5（先子后根，子先左再右）
层序遍历：5 3 8 1 4 6 9（从上到下，从左到右）

前序遍历

class BstNode:
    """二叉树节点"""
    __slots__ = ('_item', '_left', '_right')#固定集合的属性分配空间,省内存

    def __init__(self, item, left=None, right=None):
        self._item = item
        self._left = left
        self._right = right
class BST:
	#递归实现
	def print_preOrder(self):
	   print("前序遍历的递归实现：", end="")#这个打印只是为了文字标注打印出来的内容是归属什么遍历，可忽略
	   self.__print_preOrder(self._root)
	   print()#这个打印只是为了隔开一行，方便观看，和实际代码无关系
	
	def __print_preOrder(self, node):
	   if node is None:
	       return None
	   print('[', node._item, ']', end=" ")#打印放在最前
	   self.__print_preOrder(node._left)
	   self.__print_preOrder(node._right)
	
	
	#迭代实现
	def print_preOrder_iteration(self):
	       """借助栈来实现，每次先把当前节点放入栈，弹出去并记录该值，
	       把弹出去节点的左右节点加进去，弹出左边节点，一直往下……
	       （这样子会从根优先遍历到左边子树底部，由于每次都是左右节点加进去先弹左边，
	       故当左边弹完，会弹同一级的右边，这样子就实现了先序遍历）"""
	       if not self._root:
	           return
	       self.stack = [self._root]
	       print("先序遍历的迭代实现：", end="")
	       while self.stack:
	           temp_node = self.stack.pop()
	           if temp_node:
	               print('[', temp_node._item, ']', end=" ")#把当前节点值打印
	               #先把右边入栈，这样子利用后进先出左边节点值
	               self.stack.append(temp_node._right)
	               self.stack.append(temp_node._left)
#输出
前序遍历的递归实现：[ 5 ] [ 3 ] [ 1 ] [ 4 ] [ 8 ] [ 6 ] [ 9 ]
先序遍历的迭代实现：[ 5 ] [ 3 ] [ 1 ] [ 4 ] [ 8 ] [ 6 ] [ 9 ]

中序遍历

class BstNode:
    """二叉树节点"""
    __slots__ = ('_item', '_left', '_right')#固定集合的属性分配空间,省内存

    def __init__(self, item, left=None, right=None):
        self._item = item
        self._left = left
        self._right = right
class BST:
    """二叉树"""
    #省略初始化定义……
 	#递归实现
    def print_midOrder(self):
        print("中序遍历的递归实现：", end="")
        self.__print_midOrder(self._root)
        print()

    def __print_midOrder(self, node):
        if node is None:
            return None
        self.__print_midOrder(node._left)
        print('[', node._item, ']', end=" ")#打印放在中间
        self.__print_midOrder(node._right)
        
    #递归另一种实现方式
    def mid_print(self):
        return self.mid_print_helper(self._root)

    def mid_print_helper(self, root):
        return self.mid_print_helper(root._left) + [root._item] + self.mid_print_helper(root._right) if root else []
        
    #迭代实现    
	def print_midOrder_iteration(self):
        """借助栈来实现"""
        if not self._root:
            return
        
        node = self._root
        self.stack = []
        print("中序遍历的迭代实现：", end="")
                
        while self.stack or node:#这里要加上or node是为了触发进去循环
            while node:#当前节点只要左边还存在，则一直加到栈里面
                self.stack.append(node) 
                node = node._left
            temp_node = self.stack.pop()
            print('[', temp_node._item, ']', end=" ")#把当前节点值打印
            if temp_node._right:#当该节点存在右子树时
                node = temp_node._right   

bst = BST()
bst.add(5)#add请自行实现
bst.add(3)
bst.add(8)
bst.add(1)
bst.add(4)
bst.add(6)
bst.add(9)
#以上add完，实现同上图所示树
bst.print_midOrder()
bst.print_midOrder_iteration()
#输出
中序遍历的递归实现：[ 1 ] [ 3 ] [ 4 ] [ 5 ] [ 6 ] [ 8 ] [ 9 ]
中序遍历的迭代实现：[ 1 ] [ 3 ] [ 4 ] [ 5 ] [ 6 ] [ 8 ] [ 9 ]

后序遍历

class BstNode:
    """二叉树节点"""
    __slots__ = ('_item', '_left', '_right')#固定集合的属性分配空间,省内存

    def __init__(self, item, left=None, right=None):
        self._item = item
        self._left = left
        self._right = right
class BST:
	#递归实现
	def print_postOrder(self):
        print("后序遍历的递归实现：", end="")
        self.__print_postOrder(self._root)
        print()  

    def __print_postOrder(self, node):
        if node is None:
            return None
        self.__print_postOrder(node._left)
        self.__print_postOrder(node._right)
        print('[', node._item, ']', end=" ")
	
	#迭代实现
	def print_postOrder_iteration(self):
        """借助栈来实现"""
        if not self._root:
            return
        self.stack = [self._root]
        res = []
        print("后序遍历的迭代实现：")    
        while self.stack:
            temp = self.stack.pop()
            res.append(temp._item)
            if temp._left:
                self.stack.append(temp._left)
            if temp._right:
                self.stack.append(temp._right)
        print(res[::-1])
#输出
后序遍历的递归实现：[ 1 ] [ 4 ] [ 3 ] [ 6 ] [ 9 ] [ 8 ] [ 5 ]
后序遍历的迭代实现：
[1, 4, 3, 6, 9, 8, 5]

层序遍历

class BstNode:
    """二叉树节点"""
    __slots__ = ('_item', '_left', '_right')#固定集合的属性分配空间,省内存

    def __init__(self, item, left=None, right=None):
        self._item = item
        self._left = left
        self._right = right
class BST:
	#递归实现
	def levelOrder(self):
        if self._root is None: return None
        print("中序遍历的迭代实现：", end="")
        print('[', self._root._item, ']', end=" ")
        self.levelOrder_helper(self._root)

    def levelOrder_helper(self, node):
        if node is None:
            return None

        if node._left:
            print('[', node._left._item, ']', end=" ")
        if node._right:
            print('[', node._right._item, ']', end=" ")

        self.levelOrder_helper(node._left)
        self.levelOrder_helper(node._right)

	#层序遍历（迭代）     
    def levelOrder_iteration(self):
        print("层序遍历的迭代实现：", end="")
        root = self._root
        #迭代实现
        """层序遍历迭代实现"""
        if root is None: return []
        stack = [[root]]#中转使用的栈
        res = []#存储结果

        while stack:#只要栈还存在值
            temp = stack.pop()
            
            for item in temp:
                res.append(item._item)

            #栈由于后进先出，所以要先入右子树再左子树
            tempnode_lst = []
            for item in temp:
                if item._left:
                    tempnode_lst.append(item._left)
                if item._right:
                    tempnode_lst.append(item._right)
            if tempnode_lst:
                stack.append(tempnode_lst)
        print(res)
#输出
层序遍历的递归实现：[ 5 ] [ 3 ] [ 8 ] [ 1 ] [ 4 ] [ 6 ] [ 9 ]
层序遍历的迭代实现：[5, 3, 8, 1, 4, 6, 9]