Python 实现二叉树的广度遍历和深度遍历

二叉树的实现

定义一个节点类：

class Node:
    """节点类"""
    def __init__(self, elem, left=None, right=None):
        self.elem = elem
        self.left = left
        self.right = right

定义一个树类：

class Tree:
    """树类"""
    def __init__(self, root=None):
        self.root = root

为树增加节点：

	# 增加节点
    def add(self, item):
        # 创建一个节点
        node = Node(item)
        if self.root is None:
            self.root = node
            return
        # 用一个队列存放根节点
        queue = [self.root]
        # 循环遍历数
        while queue:
            # 根节点出队列
            cur_node = queue.pop(0)
            # 当该节点没有左子树时，新节点连接到左边
            if not cur_node.left:
                cur_node.left = node
                return
            else:
                # 该节点存在左子树，将该左节点入队列
                queue.append(cur_node.left)
            # 当该节点没有右子树时，新节点连接到右边
            if not cur_node.right:
                cur_node.right = node
                return
            else:
                queue.append(cur_node.right)

广度（层次）遍历

	def breadth_trav(self):
        """广度遍历--层次遍历"""
        if self._root is None:
            return
        # 根节点队列
        queue = [self._root]
        # 循环遍历
        while queue:
            # 根节点出队
            cur_node = queue.pop(0)
            # 输出节点值
            print(cur_node.elem,end=" ")
            # 若该节点存在左节点
            if cur_node.left:
                # 将左节点入队
                queue.append(cur_node.left)
            if cur_node.right:
                queue.append(cur_node.right)

深度—先序遍历（递归）

	def preorder(self,root):
	        """深度先序递归遍历所有节点"""
	        if root is None:
	            return
	
	        print(root.elem,end=" ")
	        self.preorder(root.left)
	        self.preorder(root.right)

深度—先序遍历（迭代）

此法与广度遍历类似，不同的是：

1. 广度遍历取的是队头元素，先序遍历（迭代）取的是队尾元素
2. 广度遍历是先加左节点入队，后加右节点；先序遍历（迭代）先加右节点入队，后加左节点

def depth_trav(self):
        """深度---先序遍历（迭代）"""
        if self._root is None:
            return
        # 根节点列表
        queue = [self._root]
        # 循环遍历
        while queue:
            # 取根节点
            cur_node = queue.pop()
            # 输出节点值
            print(cur_node.elem,end=" ")
            
            if cur_node.right:
                queue.append(cur_node.right)
            # 若该节点存在左节点
            if cur_node.left:
                # 将左节点入队
                queue.append(cur_node.left)
            

深度—中、后序遍历（递归）

与先序遍历类似：只是调换了根节点的输出位置

	def infix(self,root):
	        """深度中序递归遍历所有节点"""
	        if root is None:
	            return
		        
	        self.infix(root.left)
	        print(root.elem,end=" ")
	        self.infix(root.right)

	def epilogue(self,root):
	        """深度后序递归遍历所有节点"""
	        if root is None:
	            return
		        
	        self.epilogue(root.left)
	        self.epilogue(root.right)
	        print(root.elem,end=" ")