class Node(object):
def __init__(self,value=None,left=None,right=None):
self.value = value
self.left = left
self.right = right
def pre_traverse(root):
"""
前序遍历
:param root:
:return:
"""
if root == None:
return
print(root.value)
pre_traverse(root.left)
pre_traverse(root.right)
def mid_traverse(root):
"""
中序遍历
:param root:
:return:
"""
if root==None:
return
mid_traverse(root.left)
print(root.value)
mid_traverse(root.right)
def after_traverse(root):
"""
后序遍历
:param root:
:return:
"""
if root==None:
return
after_traverse(root.left)
after_traverse(root.right)
print(root.value)
root=Node('D',Node('B',Node('A'),Node('C')),Node('E',right=Node('G',Node('F'))))
print('前序遍历:')
pre_traverse(root)
print('\n')
print('中序遍历:')
mid_traverse(root)
print('\n')
print('后序遍历:')
after_traverse(root)
print('\n')
preList = list('DBACEGF')
midList = list('ABCDEFG')
afterList = []
##一直二叉树前序遍历和中序遍历,求后序遍历
def find_tree(preList, midList, afterList):
if len(preList) == 0:
return
if len(preList) == 1:
afterList.append(preList[0])
return
root = preList[0]
n = midList.index(root)
find_tree(preList[1:n + 1], midList[:n], afterList)
find_tree(preList[n + 1:], midList[n + 1:], afterList)
afterList.append(root)
find_tree(preList,midList,afterList)
print(afterList)
前序遍历:
D
B
A
C
E
G
F
中序遍历:
A
B
C
D
E
F
G
后序遍历:
A
C
B
F
G
E
D
['A', 'C', 'B', 'F', 'G', 'E', 'D']
非递归
class Tree():
# 树类
def __init__(self):
self.root = Node()
def add(self, data):
# 为树加入节点
node = Node(data)
if self.root.data == -1: # 如果树为空,就对根节点赋值
self.root = node
else:
my_queue = []
treeNode = self.root
my_queue.append(treeNode)
while my_queue: # 对已有的节点进行层次遍历
treeNode = my_queue.pop(0)
if not treeNode.left:
treeNode.left = node
return
elif not treeNode.right:
treeNode.right = node
return
else:
my_queue.append(treeNode.left)
my_queue.append(treeNode.right)
def pre_order_stack(self, root): # 堆栈实现前序遍历(非递归)
if not root:
return
myStack = []
node = root
while myStack or node:
while node: # 从根节点开始,一直寻找他的左子树
print(node.data)
myStack.append(node)
node = node.left
node = myStack.pop() # while结束表示当前节点node为空,即前一个节点没有左子树了
node = node.right # 开始查看它的右子树
def in_order_stack(self, root): # 堆栈实现中序遍历(非递归)
if not root:
return
myStack = []
node = root
while myStack or node: # 从根节点开始,一直寻找它的左子树
while node:
myStack.append(node)
node = node.left
node = myStack.pop()
print(node.data)
node = node.right
def post_order_stack(self, root): # 堆栈实现后序遍历(非递归)
# 先遍历根节点,再遍历右子树,最后是左子树,这样就可以转化为和先序遍历一个类型了,最后只把遍历结果逆序输出就OK了。
if not root:
return
myStack1 = []
myStack2 = []
node = root
while myStack1 or node:
while node:
myStack2.append(node)
myStack1.append(node)
node = node.right
node = myStack1.pop()
node = node.left
while myStack2:
print(myStack2.pop().data)
datas = [2, 3, 4, 5, 6, 7, 8, 9]
tree = Tree() # 新建一个树对象
for data in datas:
tree.add(data) # 逐个加入树的节点