二叉树最强总结(python实现)
这篇文章总结了关于二叉树的创建和各种遍历方式。
二叉树的创建方式
- 通过层次遍历顺序创建
- 先序遍历顺序(带上叶子结点标识符)创建
- 先序顺序+中序顺序
- 中序顺序+后序顺序
二叉树的递归方式
- 先序遍历(递归+非递归)
- 中序遍历(递归+非递归)
- 后序遍历(递归+非递归)
- 广度优先遍历(BFS)
首先来定义一下节点的结构
class Node():
def __init__(self, val):
self.val = val
self.left = None
self.right = None然后定义树类
class BinaryTree():
def __init__(self):
self.root = None
self.queue = [] #用来存放正在操作的三个树节点，分别是root,left和right
self.create_queue = [] #用来存放先序序列来创建二叉树
pass然后开始实现函数，这些函数都是在BinaryTree这个类下定义的。
通过先序序列带有叶子结点标识符创建二叉树
#通过先序序列创建二叉树，没有左右子节点被标记为'#'
def createTree(self):
current = self.create_queue.pop(0)
if current != '#':
new_node = Node(current)
if self.root is None:
self.root = new_node
new_node.left = self.createTree()
new_node.right = self.createTree()
return new_node
return None通过层次遍历顺序创建二叉树
#通过层次遍历顺序创建二叉树
def add(self, val):
new_node = Node(val)
self.queue.append(new_node)
if self.root is None:
self.root = new_node
else:
tree_node = self.queue[0]
if tree_node.left is None:
tree_node.left = new_node
else:
tree_node.right = new_node
self.queue.pop(0)通过 先序+中序 创建二叉树
#通过前序序列和中序序列创建二叉树
def create_tree(self, pre_order, mid_order):
if len(pre_order) == 0:
return None
new_node = Node(pre_order[0])
if self.root is None:
self.root = new_node
i = mid_order.index(pre_order[0])
print(i)
new_node.left = self.create_tree(pre_order[1:1+i], mid_order[:i])
new_node.right = self.create_tree(pre_order[1+i:], mid_order[i+1:])
return new_node通过 中序+后序 创建二叉树
#通过中序和后序创建二叉树
def construct_tree(self, mid_order, post_order):
length = len(post_order)
if length == 0:
return None
new_node = Node(post_order[-1])
if self.root is None:
self.root = new_node
i = mid_order.index(post_order[-1])
new_node.left = self.construct_tree(mid_order[:i], post_order[:i])
new_node.right = self.construct_tree(mid_order[i+1:], post_order[length-2-i:length-1])
return new_node以上是全部创建二叉树的方法，下面开始实现遍历方法。
先序遍历(递归)
#通过递归进行先序遍历
def recursion_vlr(self, root):
if root is None:
return
print(root.val)
self.recursion_vlr(root.left)
self.recursion_vlr(root.right)先序遍历(非递归)
#通过栈非递归进行先序遍历
def pre_order_stack(self, root):
if root is None:
return
mystack = []
node = root
while mystack or node:
while node:
print(node.val)
mystack.append(node)
node = node.left
node = mystack.pop()
node = node.right中序遍历(递归)
#通过递归进行中序遍历
def recursion_lvr(self, root):
if root is None:
return
self.recursion_lvr(root.left)
print(root.val)
self.recursion_lvr(root.right)中序遍历(非递归)
#通过栈非递归进行中序遍历
def mid_order_stack(self, root):
if root is None:
return
mystack = []
node = root
while mystack or node:
while node:
mystack.append(node)
node = node.left
node = mystack.pop()
print(node.val)
node = node.right后序遍历(递归)
#通过递归进行后序遍历
def recursion_lrv(self, root):
if root is None:
return
self.recursion_lrv(root.left)
self.recursion_lrv(root.right)
print(root.val)后序遍历(非递归)
#通过栈非递归进行后序遍历，先遍历右子树，在遍历左子树，最后逆序数出
def post_order_stack(self, root):
if root is None:
return
mystack1 = []
#stack2是为了逆序输出，全都存在2栈中，1栈的作用是按照右、左的顺序遍历节点存入2栈
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().val)广度优先遍历(BFS)
#利用队列进行广度优先遍历BFS
def level_scan(self):
queue = []
current = self.root
queue.append(current)
while queue:
current = queue.pop(0)
print(current.val)
if current.left:
queue.append(current.left)
if current.right:
queue.append(current.right)整个项目源码：传送门