二叉树的遍历方式：
1、深度优先遍历方式
1.1 前序遍历 （递归、非递归）
1.2 中序遍历 （递归、非递归）
1.3 后序遍历 （递归、非递归）
2、宽度优先遍历方式
'''树的构建：
10
6 14
4 8 12 16
'''
class Node(object):
'''节点类'''
def __init__(self, elem=-1, lchild=None, rchild=None):
self.elem = elem
self.lchild = lchild
self.rchild = rchild
class Tree(object):
'''树类'''
def __init__(self):
self.root = Node()
self.mq = []
self.res_preorder = []
self.res_inorder = []
self.res_postorder = []
def add(self, elem):
'''为树添加节点'''
node = Node(elem)
if self.root.elem == -1: # 如果树是空的，对根节点赋值
self.root = node
self.mq.append(self.root)
else:
treeNode = self.mq[0]
if treeNode.lchild == None:
treeNode.lchild = node
self.mq.append(treeNode.lchild) # 将新的结点加入mq中，当结点的左、右孩齐全的时候将从mq中删除该结点
else:
treeNode.rchild = node
self.mq.append(treeNode.rchild)
self.mq.pop(0) # 如果该结点存在右子树则将此结点丢弃 ?妙啊啊啊啊！
def preorder_traversal(self, root):
'''前序遍历： 递归实现
先访问根节点，再访问左子节点，最后访问右子节点
'''
if root == None:
return
self.res_preorder.append(root.elem)
self.preorder_traversal(root.lchild)
self.preorder_traversal(root.rchild)
def inorder_traversal(self, root):
'''中序遍历： 递归实现
先访问左子节点，再访问根节点，最后访问右子节点
'''
if root == None:
return
self.inorder_traversal(root.lchild)
self.res_inorder.append(root.elem)
self.inorder_traversal(root.rchild)
def postorder_traversal(self, root):
'''后序遍历： 递归实现
先访问左子节点，再访问右子节点，最后访问根节点
'''
if root == None:
return
self.postorder_traversal(root.lchild)
self.postorder_traversal(root.rchild)
self.res_postorder.append(root.elem)
def preorder_traversal1(self, root):
'''前序遍历： 栈实现
先访问根节点，再访问左子节点，最后访问右子节点
'''
if root == None:
return
mystack = [] # 用栈实现后进先出，弹出最近一个没有左子树的节点
node = root
while node or mystack:
while node: # 从根节点开始，一直寻找它的左子树
print(node.elem)
mystack.append(node)
node = node.lchild
node = mystack.pop()
print('*', node.elem)
node = node.rchild # 开始查看右子树
def inorder_traversal1(self, root):
'''中序遍历： 栈实现
先访问左子节点，再访问根节点，最后访问右子节点
'''
if root == None:
return
mystack = []
node = root
while node or mystack:
while node: # 从根节点开始，一直寻找它的左子树
mystack.append(node)
node = node.lchild
node = mystack.pop() # 叶节点的父节点
print(node.elem)
node = node.rchild # 开始查看右子树
def postorder_traversal1(self, root):
'''后序遍历： 栈实现
先访问左子节点，再访问右子节点，最后访问根节点
'''
if root == None:
return
mystack1 = []
mystack2 = []
mystack1.append(root)
while mystack1:
node = mystack1.pop()
if node.lchild:
mystack1.append(node.lchild)
if node.rchild:
mystack1.append(node.rchild)
mystack2.append(node)
while mystack2:
print(mystack2.pop().elem)
if __name__ == '__main__':
# 生成十个数据作为树节点
elems = [10, 6, 14, 4, 8, 12, 16]
# 新建一个树对象
tree = Tree()
for elem in elems:
tree.add(elem)
# # 输出递归结果
# print('树的前序遍历')
# tree.preorder_traversal(tree.root)
# print(tree.res_preorder)
# print('树的中序遍历')
# tree.inorder_traversal(tree.root)
# print(tree.res_inorder)
print('树的后序遍历')
tree.postorder_traversal(tree.root)
print(tree.res_postorder)
# 输出非递归结果
# tree.preorder_traversal1(tree.root)
# print('******************************')
# tree.inorder_traversal1(tree.root)
print('******************************')
tree.postorder_traversal1(tree.root)
