python实现 完全二叉树思路详解（添加，广度遍历，深度遍历）

首先说明完全二叉树的定义：
一个完全二叉树必须符合以下两个规则，1.树的倒数第二层必须是满的，2.树的最后一层从左到右紧密排序。
本次案例使用的二叉树如下图：

首先把模版定义好

class Node(object):
    def __init__(self, item):
    	# 每个节点都共有的三个属性
        self.item = item
        self.left_child = None
        self.right_child = None

class Tree(object):
    # 完全二叉树
    def __init__(self):
    	# 二叉树的根节点
        self.tree_root = None

二叉树添加元素的思路
1。首先判断是不是空树，如果是空树，直接添加到根节点
2。将根节点入队列
3。根节点出队列
4。判断是否有左节点，没有则挂上，有入队列
5。判断是否有右节点，没有则挂上，有入队列
6。重复第4步和第5步

    def add1(self, item):
        node = Node(item)  					# 先获取到节点数据
        if self.tree_root is None:			# 判断是不是空树
            self.tree_root = node
            return
        self.que.put(self.tree_root)		# 根节点入队列
        
        while not self.que.empty():			# 循环退出的条件是队列为空
            tree_node = self.que.get()		# 根节点出队列
            if tree_node.left_child is None:	# 如果左孩子为空，添加并退出
                tree_node.left_child = node
                return
            else:							# 如果不为空，左孩子入队列
                self.que.put(tree_node.left_child)
                
            if tree_node.right_child is None:  # 如果右孩子为空，添加并退出
                tree_node.right_child = node
                return
            else:							# 如果不为空，右孩子入队列
                self.que.put(tree_node.left_child)
            
            self.que.task_done()  			 # 计数器减一
	

上面
添加使用的是python自带的queue这个包，还有另一种方式，使用列表实现队列的作用

    def add2(self, item):
    
        node = Node(item)
        # 如果是棵空树，直接将节点挂到根上
        if self.tree_root is None:
            self.tree_root = node
            return
        # 将跟节点入队列，
        que = []
        que.insert(0, self.tree_root)		# insert 把元素添加到列表第一位

        while que != []: 				    # 退出循环条件，列表不为空
            element = que.pop()  		    # 元素出队列的方式
            # 如果左孩子为空，添加到左节点，否则入队列
            if element.left_child is None:
                element.left_child = node
                return
            else:
                que.insert(0, element.left_child)

            # 如果右孩子为空，添加到节右点，否则入队列
            if element.right_child is None:
                element.right_child = node
                return
            else:
                que.insert(0, element.right_child)

树添加完之后，查看则需要遍历，广度遍历较为简单，思路如下：
1。根节点为空，直接退出
2。根节点入队列
3。根节点出队列
4。检查节点是否有左右子节点，有则打印，并且入队列
5。重复第四步

在这里插入代码片

def breadth_traverse(self):
    if self.tree_root is None:
        print('空的二叉树')
        return
    que = []
    que.insert(0, self.tree_root)					# 根节点入队列
    while que != []:
        data = que.pop()						
        print(data.item, end=" ")					# 直接打印 节点的值
        if data.left_child is not None:			# 如果左孩子不为空，入队列
            que.insert(0, data.left_child)
        if data.right_child is not None:			# 如果右孩子不为空，入队列
            que.insert(0, data.right_child)

接下来是深度遍历，深度遍历分三种，主要使用到的技术是递归，递归解释起来比较复杂，最好自己打断点看代码执行步骤，代码如下：

    def depth_traverse1(self, tree_root):
        """
        深度遍历（先序：根左右）
        :return:
        """
        # 遍历退出的条件
        if tree_root is None:
            return
        print(tree_root.item, end=" ")  # 首先打印根节点
        self.depth_traverse1(tree_root.left_child)
        self.depth_traverse1(tree_root.right_child)
        
    def depth_traverse2(self, tree_root):
        """
        深度遍历（中序：左根右）
        :return:
        """
        if tree_root is None:
            return None
        self.depth_traverse2(tree_root.left_child)
        print(tree_root.item, end=" ")
        self.depth_traverse2(tree_root.right_child)

    def depth_traverse3(self, tree_root):
        """
        深度遍历（后序：左右根）
        :return:
        """
        if tree_root is None:
            return
        self.depth_traverse3(tree_root.left_child)
        self.depth_traverse3(tree_root.right_child)
        print(tree_root.item, end=" ")

以上代码测试数据如下：

if __name__ == '__main__':
    tree = Tree()
    tree.add(1)
    tree.add(2)
    tree.add(3)
    tree.add(4)
    tree.add(5)
    tree.add(6)
    tree.add(7)
    tree.add(8)
    tree.add(9)
    tree.add(10)

    tree.breadth_traverse()
    print()
    tree.depth_traverse1(tree.tree_root)
    print()
    tree.depth_traverse2(tree.tree_root)
    print()
    tree.depth_traverse3(tree.tree_root)

执行结果如下：

1 2 3 4 5 6 7 8 9 10 
1 2 4 8 9 5 10 3 6 7 
8 4 9 2 10 5 1 6 3 7 
8 9 4 10 5 2 6 7 3 1