1.基本的构造,以及集中遍历的实现
#encoding=utf-8
from collections import deque
#定义一个节点类
class Node:
def __init__(self,elem=-1,lchild=None,rchild=None):
self.elem=elem
self.lchild=lchild
self.rchild=rchild
class Tree:
def __init__(self,root=None):
self.root=root
#利用层序遍历向树中添加元素
def add(self,elem):
node=Node(elem)
if self.root==None:
self.root=node
else:
queue=deque()
queue.append(self.root)
while queue:
cur_node=queue.popleft()
if cur_node.lchild is None:
cur_node.lchild=node
#return 是结束查找,这个很重要(函数返回)
return
else:
queue.append(cur_node.lchild)
if cur_node.rchild is None:
cur_node.rchild=node
return
else:
queue.append(cur_node.rchild)
#层序遍历
def breadth_travl(self):
if self.root==None:
return
else:
queue=deque()
queue.append(self.root)
while queue:
cur_node=queue.popleft()
print(cur_node.elem,end=" ")
if cur_node.lchild is not None:
queue.append(cur_node.lchild)
if cur_node.rchild is not None:
queue.append(cur_node.rchild)
#前序遍历
#关于node参数:因为是递归遍历,所以一定存在子树的根,也就是需要一个node参数来代表子树的根
def pre_oder(self,node):
#递归结束的条件是:叶子节点的左和右子树是none那么它在执行self.pre_oder(node.lchild)就改返回
if node is None:
return
print(node.elem,end=" ")
self.pre_oder(node.lchild)
self.pre_oder(node.rchild)
#中序遍历
def in_oder(self,node):
if node==None:
return
self.in_oder(node.lchild)
print(node.elem,end=" ")
self.in_oder(node.rchild)
#后序遍历
def post_oder(self,node):
if node==None:
return
self.post_oder(node.lchild)
self.pre_oder(node.rchild)
print(node.elem,end=" ")
if __name__=="__main__":
tree=Tree()
for i in range(1,7):
tree.add(i)
tree.breadth_travl()
print()
tree.pre_oder(tree.root)
print()
tree.in_oder(tree.root)
print()
tree.post_oder(tree.root)
2.已知前序和中序,求后序
#encoding=utf-8
from collections import deque
#定义一个节点类
class Node:
def __init__(self,elem=-1,lchild=None,rchild=None):
self.elem=elem
self.lchild=lchild
self.rchild=rchild
class Tree:
def __init__(self,root=None):
self.root=root
#利用层序遍历向树中添加元素
def add(self,elem):
node=Node(elem)
if self.root==None:
self.root=node
else:
queue=deque()
queue.append(self.root)
while queue:
cur_node=queue.popleft()
if cur_node.lchild is None:
cur_node.lchild=node
#return 是结束查找,这个很重要(函数返回)
return
else:
queue.append(cur_node.lchild)
if cur_node.rchild is None:
cur_node.rchild=node
return
else:
queue.append(cur_node.rchild)
#层序遍历
def breadth_travl(self):
if self.root==None:
return
else:
queue=deque()
queue.append(self.root)
while queue:
cur_node=queue.popleft()
print(cur_node.elem,end=" ")
if cur_node.lchild is not None:
queue.append(cur_node.lchild)
if cur_node.rchild is not None:
queue.append(cur_node.rchild)
#前序遍历
#关于node参数:因为是递归遍历,所以一定存在子树的根,也就是需要一个node参数来代表子树的根
def pre_oder(self,node):
#递归结束的条件是:叶子节点的左和右子树是none那么它在执行self.pre_oder(node.lchild)就改返回
if node is None:
return
print(node.elem,end=" ")
self.pre_oder(node.lchild)
self.pre_oder(node.rchild)
#中序遍历
def in_oder(self,node):
if node==None:
return
self.in_oder(node.lchild)
print(node.elem,end=" ")
self.in_oder(node.rchild)
#后序遍历
def post_oder(self,node):
if node==None:
return
self.post_oder(node.lchild)
self.pre_oder(node.rchild)
print(node.elem,end=" ")
def re_construct_tree(self,pre,mid):
if len(pre)==0:
return None
root=Node(pre[0])
mid_index=mid.index(pre[0])
root.lchild=self.re_construct_tree(pre[1:mid_index+1],mid[0:mid_index])
root.rchild=self.re_construct_tree(pre[mid_index+1:],mid[mid_index+1:])
return root
if __name__=="__main__":
pre = [1,2,4,5,3,6]
tin = [4,2,5,1,6,3]
tree=Tree()
root=tree.re_construct_tree(pre,tin)
tree.post_oder(root)
3.已知后序和中序求前序
#encoding=utf-8
from collections import deque
#定义一个节点类
class Node:
def __init__(self,elem=-1,lchild=None,rchild=None):
self.elem=elem
self.lchild=lchild
self.rchild=rchild
class Tree:
def __init__(self,root=None):
self.root=root
#利用层序遍历向树中添加元素
def add(self,elem):
node=Node(elem)
if self.root==None:
self.root=node
else:
queue=deque()
queue.append(self.root)
while queue:
cur_node=queue.popleft()
if cur_node.lchild is None:
cur_node.lchild=node
#return 是结束查找,这个很重要(函数返回)
return
else:
queue.append(cur_node.lchild)
if cur_node.rchild is None:
cur_node.rchild=node
return
else:
queue.append(cur_node.rchild)
#层序遍历
def breadth_travl(self):
if self.root==None:
return
else:
queue=deque()
queue.append(self.root)
while queue:
cur_node=queue.popleft()
print(cur_node.elem,end=" ")
if cur_node.lchild is not None:
queue.append(cur_node.lchild)
if cur_node.rchild is not None:
queue.append(cur_node.rchild)
#前序遍历
#关于node参数:因为是递归遍历,所以一定存在子树的根,也就是需要一个node参数来代表子树的根
def pre_oder(self,node):
#递归结束的条件是:叶子节点的左和右子树是none那么它在执行self.pre_oder(node.lchild)就改返回
if node is None:
return
print(node.elem,end=" ")
self.pre_oder(node.lchild)
self.pre_oder(node.rchild)
#中序遍历
def in_oder(self,node):
if node==None:
return
self.in_oder(node.lchild)
print(node.elem,end=" ")
self.in_oder(node.rchild)
#后序遍历
def post_oder(self,node):
if node==None:
return
self.post_oder(node.lchild)
self.pre_oder(node.rchild)
print(node.elem,end=" ")
def re_construct_tree(self,post,mid):
if len(post)==0:
return None
root=Node(post[-1])
mid_index=mid.index(post[-1])
root.lchild=self.re_construct_tree(post[:mid_index],mid[0:mid_index])
root.rchild=self.re_construct_tree(post[mid_index:-1],mid[mid_index+1:])
return root
if __name__=="__main__":
post = [4, 5, 2, 3, 6, 1]
tin = [4, 2, 5, 1, 6, 3]
tree=Tree()
root=tree.re_construct_tree(post,tin)
tree.pre_oder(root)
下面的代码中整合了上面的代码以及开了几个list(不能开deque因为deque不支持切片操作)来存储每次遍历后的值,方便后面的使用,以后找时间优化注释
from collections import deque
#用来保存层序的队列
breadth_order_list=[]
#用来保存前序的队列
former_order_list=[]
#用来保存中序的队列
mid_order_list=[]
#用来保存后序的队列
post_order_list=[]
class Node():
def __init__(self,elem=-1,lchild=None,rchild=None):
self.elem=elem
self.lchild=lchild
self.rchild=rchild
class Tree():
def __init__(self,root=None):
self.root=root
def add(self, elem):
node = Node(elem)
if self.root == None:
self.root = node
else:
queue1 = deque()
queue1.append(self.root)
while queue1:
cur_node = queue1.popleft()
if cur_node.lchild is None:
cur_node.lchild = node
return
else:
queue1.append(cur_node.lchild)
if cur_node.rchild is None:
cur_node.rchild = node
return
else:
queue1.append(cur_node.rchild)
#层序
def breadth_oder(self,breth_list):
if self.root==None:
return
queue=deque()
queue.append(self.root)
while queue:
cur_node=queue.popleft()
breth_list.append(cur_node.elem)
print(cur_node.elem,end=" ")
if cur_node.lchild is not None:
queue.append(cur_node.lchild)
if cur_node.rchild is not None:
queue.append(cur_node.rchild)
#前序
def former_order(self,node,former_list):
if node==None:
return
else:
former_list.append(node.elem)
print(node.elem,end=" ")
if node.lchild is not None:
self.former_order(node.lchild,former_list)
if node.rchild is not None:
self.former_order(node.rchild,former_list)
#中序
def mid_order(self,node,mid_list):
if node is None:
return
else:
self.mid_order(node.lchild,mid_list)
mid_list.append(node.elem)
print(node.elem,end=" ")
self.mid_order(node.rchild,mid_list)
#后序
def post_order(self,node,post_list):
if node is None:
return
else:
self.post_order(node.lchild,post_list)
self.post_order(node.rchild,post_list)
post_list.append(node.elem)
print(node.elem,end=" ")
#1.已知前序,中序求后序
def tree_transform_1(self,pre,mid):
if len(pre)==0:
return
root=Node(pre[0])
mid_index=mid.index(pre[0])
root.lchild=self.tree_transform_1(pre[1:mid_index+1],mid[0:mid_index])
root.rchild=self.tree_transform_1(pre[mid_index+1:],mid[mid_index+1:])
return root
#2.已知后序,中序,求前序
def tree_transform_2(self,post,mid):
if len(post)==0:
return
root=Node(post[-1])
mid_index=mid.index(post[-1])
root.lchild=self.tree_transform_2(post[:mid_index],mid[0:mid_index])
root.rchild=self.tree_transform_2(post[mid_index:-1],mid[mid_index+1:])
return root
if __name__=="__main__":
tree=Tree()
for i in range(1,6):
tree.add(i)
tree.breadth_oder(breadth_order_list)
print()
tree.former_order(tree.root,former_order_list)
print()
tree.mid_order(tree.root,mid_order_list)
print()
tree.post_order(tree.root,post_order_list)
print()
#1.已知前序,中序,求后序
main_post_order_list=[]
root1=tree.tree_transform_1(former_order_list,mid_order_list)
tree.post_order(root1,main_post_order_list)
print()
#2.已知后序,中序,求前序
main_former_order_list=[]
root2=tree.tree_transform_2(post_order_list,mid_order_list)
tree.former_order(root2,main_former_order_list)