class TreeNode:
def __init__(self,x):
self.value = x
self.left = None
self.right = None
class Tree:
def __init__(self):
self.queue = [] #用队列存储树的结点
self.flag = 0 #存树根后flag置为1
self.root = None
#建树
def createTree(self,arr):
while True:
if len(arr) == 0:
return
if self.flag == 0: #根不存在
self.root = TreeNode(arr[0])
self.queue.append(self.root) #将树根存到队列
self.flag = 1
arr.pop(0)
else:
treeNode = self.queue[0] #队列中的第一个节点
if treeNode.left is None:
treeNode.left = TreeNode(arr[0])
self.queue.append(treeNode.left)
arr.pop(0)
else:
treeNode.right = TreeNode(arr[0])
self.queue.append(treeNode.right)
arr.pop(0)
self.queue.pop(0)
#递归实现前序遍历
def pre(self,root):
if root is None:
return
else:
print(root.value,end=' ')
self.pre(root.left)
self.pre(root.right)
#递归实现中序遍历
def tin(self,root):
if root is None:
return
else:
self.tin(root.left)
print(root.value,end=' ')
self.tin(root.right)
#递归实现后序遍历
def post(self,root):
if root is None:
return
else:
self.post(root.left)
self.post(root.right)
print(root.value,end=' ')
#队栈实现前序遍历(非递归)
def pre_stack(self,root):
if root is None:
return
stack = [] #定义一个栈,存储节点
while stack or root:
while root:
print(root.value,end=' ') #从根结点开始一直输出左孩子
stack.append(root)
root = root.left
#该节点不存在左孩子时,该节点出栈,搜索该节点右孩子
node = stack.pop()
root = node.right
#栈实现中序遍历(非递归)
def tin_stack(self,root):
if root is None:
return
stack = []
while stack or root:
while root:
stack.append(root)
root = root.left
node = stack.pop()
print(node.value,end=' ')
root = node.right
#栈实现后序遍历(非递归)
# 模拟逆序(根右左)存入Stack2,然后在stack2逆序输出
# (根右左)与(根左右)类似,入栈stack1前读(根、右),出栈后指针变更再读左
def post_stack(self,root):
if root is None:
return
stack1 = []
stack2 = []
while stack1 or root:
while root:
stack2.append(root.value)
stack1.append(root)
root = root.right
node = stack1.pop()
root = node.left
print(stack2[::-1])
#广度优先遍历,层次遍历
def level(self,root):
stack = []
stack.append(root)
while stack:
head = stack.pop(0)
print(head.value,end=' ')
if head.left:
stack.append(head.left)
if head.right:
stack.append(head.right)
#获取树的深度(递归)
def get_depth_digui(self,root):
if not root:
return 0
left = right = 0
left = self.get_depth_digui(root.left)
right = self.get_depth_digui(root.right)
return max(left,right)+1
#获取树的深度(非递归)
#利用广度优先遍历
def get_depth(self,root):
stack1 = []
stack2 = []
stack1.append(root)
stack2.append(1)
while stack1:
head = stack1.pop(0)
p = stack2.pop(0)
if head.left:
stack1.append(head.left)
stack2.append(p+1)
if head.right:
stack2.append(p+1)
stack1.append(head.right)
return p
#已知前序中序重构二叉树
def reconstruct_tree(pre,tin):
if not pre and not tin:
return
if set(pre) != set(tin):
return
root = TreeNode(pre[0])
i = tin.index(pre[0])
self.reconstruct_tree(pre[1:i+1],tin[:i])
self.reconstruct_tree(pre[i+1:],tin[i+1:])
return root
if __name__ == '__main__':
arr = [0,1,2,3,4,5,6,7,8,9]
tree = Tree()
tree.createTree(arr)
tree.pre(tree.root)
print()
tree.tin(tree.root)
print()
tree.post(tree.root)
print()
tree.pre_stack(tree.root)
print()
tree.tin_stack(tree.root)
print()
tree.post_stack(tree.root)
tree.level(tree.root)
print()
print(tree.get_depth_digui(tree.root))
print(tree.get_depth(tree.root))
二叉树遍历
最新推荐文章于 2024-01-27 15:36:29 发布