【用python实现用二叉链表表示的二叉树类】

用python实现用二叉链表表示的二叉树类，并完成以下操作：（1）创建二叉树；（2）先序、中序、后续遍历二叉树；（3）中序遍历请用非递归算法。

#1、首先我们需要一个节点类和一个树类。
#创建节点类
class Node(object):  
    def __init__(self, item, left = None, right = None):
        self.elem=item
        self.lchild = left
        self.rchild = right

#创建树类
class BinaryTree(object):
    def __init__(self):
        self.root = None     # 给个root根节点，一开始为空，然后添加节点

#2、同时树需要一个add方法来把新节点加进去 添加元素
    def add(self, item): #相当于队列，在左侧弹出元素，在右侧添加元素 
    
       #当根节点为空时
        if self.root is None:
            self.root = Node(item) #当根节点为空时，直接把节点放在空节点的位置，相当于根节点  
            return         
        queue = []
        queue.append(self.root)#将根节点放入列表
        
        while queue:    #当队列不为空时       
            node = queue.pop(0)#弹出0位置上的元素，作为当前需处理的元素
            
            if not node.lchild: #判断当前元素的左子树是否为空 if node.lchild is None:
                node.lchild = Node(item)#if判断是空，则直接将元素接在上面
                return
            else:
                queue.append(node.lchild)
                
            if not node.rchild: #判断当前元素的右子树是否为空 if node.rchild is None:
                node.rchild = Node(item)#if判断是空，则直接将元素接在上面
                return
            else:
                queue.append(node.rchild)
                
#3、广度优先遍历 深度从上到下，层里从左到右
    def breadh_travel(self):
        
        if self.root is None:
            return
        
        queue = []
        queue.append(self.root)
    
        while len(queue)>0:
            node = queue.pop(0)
            print(node.elem, end=" ")
            if node.lchild:
                queue.append(node.lchild)
            if node.rchild:
                queue.append(node.rchild)

#4、先序遍历
#根节点->左子树->右子树
    def preorder_travel(self, root):
        
        if root is None:#若节点为空，则直接返回
            return

        print(root.elem, end=" ")#D
        self.preorder_travel(root.lchild)#L
        self.preorder_travel(root.rchild)#R
        

#5.1、中序遍历
#左子树->根节点->右子树
    def inorder_travel(self, root):
	    if root:#若节点不是空的
	        self.inorder_travel(root.lchild)#L       
	        print(root.elem, end=" ")#D
	        self.inorder_travel(root.rchild)#R
#5.2中序遍历二叉树的非递归过程            
#class Solution(object):
    def inorderTraversal_1(self, root):# 堆栈实现中序遍历（非递归）
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return
        stack = []
        node = root
        while node or stack: # 从根节点开始，一直寻找它的左子树
            while node:
                stack.append(node)
                node = node.lchild
            #if stack:
            node = stack.pop()
            print(node.elem,end=' ')                
            node = node.rchild


#6、后序遍历
#左子树->右子树->根节点
    def postorder_travel(self, root):
	    if root:
	        self.postorder_travel(root.lchild)#L
	        self.postorder_travel(root.rchild)#R
	        print(root.elem, end=" ")#D
#主程序
if __name__=='__main__':
#if name == 'main':
    tree = BinaryTree()
    tree.add(0)
    tree.add(1)
    tree.add(2)
    tree.add(3)
    tree.add(4)
    tree.add(5)
    tree.add(6)
    tree.add(7)
    
    print("广度优先遍历")
    tree.breadh_travel()
    print('\n')
    print("先序遍历")
    tree.preorder_travel(tree.root)
    print('\n')
    print('中序遍历递归')
    tree.inorder_travel(tree.root)
    print('\n')
    print('中序遍历非递归')
    tree.inorderTraversal_1(tree.root)
    print('\n')
    print("后序遍历")
    tree.postorder_travel(tree.root)

这里是引用：参考文章
https://blog.csdn.net/bigpieapple/article/details/100730882