闲来无事,又重新复习了一下二叉树遍历,最后附有完整的测试代码和运行结果。
文章目录
- 1. 二叉树的先序遍历(非递归算法)
- 2. 二叉树的先序遍历(递归算法)
- 3. 二叉树的中序遍历(非递归算法)
- 4. 二叉树的中序遍历(递归算法)
- 5. 二叉树的后序遍历(非递归算法)
- 6. 二叉树的后序遍历(递归算法)
- 7. 二叉树的广度优先遍历(层次遍历)
- 完整测试代码和运行结果
1. 二叉树的先序遍历(非递归算法)
def preorder_traversal(root):
# 方法1
stack = []
cur = root
while len(stack) != 0 or cur is not None:
while cur is not None: # 一直到最左下
print(cur.val)
stack.append(cur)
cur = cur.left
cur = stack.pop()
cur = cur.right
# 方法2
# if root is None:
# return
# stack = [root]
# while len(stack) != 0:
# cur = stack.pop()
# # 访问当前结点
# print(cur.val)
# if cur.right is not None: # 先压入右子树,那么右子树在下,左子树则在上
# stack.append(cur.right)
# if cur.left is not None:
# stack.append(cur.left)
2. 二叉树的先序遍历(递归算法)
def preorder_traversal_recursion(root):
if root is None:
return
print(root.val)
preorder_traversal_recursion(root.left)
preorder_traversal_recursion(root.right)
3. 二叉树的中序遍历(非递归算法)
def inorder_traversal(root):
stack = []
cur = root
while len(stack) != 0 or cur is not None:
while cur is not None:
stack.append(cur)
cur = cur.left
cur = stack.pop()
print(cur.val)
cur = cur.right
4. 二叉树的中序遍历(递归算法)
def inorder_traversal_recursion(root):
if root is None:
return
inorder_traversal_recursion(root.left)
print(root.val)
inorder_traversal_recursion(root.right)
5. 二叉树的后序遍历(非递归算法)
def postorder_traversal(root):
stack= []
flags = [] # 0表示从左子树返回,继续访问右节点;1表示从右子树返回,弹出并访问当前结点
cur = root
while len(stack) != 0 or cur is not None:
while cur is not None:
stack.append(cur)
flags.append(0)
cur = cur.left
cur = stack.pop()
flag = flags.pop()
if flag == 0:
stack.append(cur)
flags.append(1)
cur = cur.right
else:
print(cur.val)
cur = None # 关键一步
6. 二叉树的后序遍历(递归算法)
def postorder_traversal_recursion(root):
if root is None:
return
postorder_traversal_recursion(root.left)
postorder_traversal_recursion(root.right)
print(root.val)
7. 二叉树的广度优先遍历(层次遍历)
def level_traversal(root):
if root is None:
return
queue = [root]
end = queue[-1]
level = 1
print("level " + str(level))
while len(queue) != 0:
cur = queue.pop(0)
print(cur.val)
if cur.left is not None:
queue.append(cur.left)
if cur.right is not None:
queue.append(cur.right)
if cur == end:
level += 1
if len(queue) != 0:
end = queue[-1]
print("level " + str(level))
完整测试代码和运行结果
# !usr/bin/env python
# -*- coding: utf-8 -*-
"""
@Author: ywm_up
@File: binary_tree_traversal.py
@Time: 2021/8/11 10:42
"""
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class BinaryTree:
def __init__(self):
self.root = None
def build_tree(self, data, index):
if index >= len(data):
return None
if data[index] == "NaN":
return None
root = TreeNode(int(data[index]))
left_index = 2 * index + 1
right_index = 2 * index + 2
root.left = self.build_tree(data, left_index)
root.right = self.build_tree(data, right_index)
return root
def init_tree(self, data):
if len(data) == 0:
return None
if data[0] == 'NaN':
return None
root = self.build_tree(data, 0)
return root
# 1. 二叉树的先序遍历(非递归算法)
def preorder_traversal(root):
# 方法1
stack = []
cur = root
while len(stack) != 0 or cur is not None:
while cur is not None: # 一直到最左下
print(cur.val)
stack.append(cur)
cur = cur.left
cur = stack.pop()
cur = cur.right
# 方法2
# if root is None:
# return
# stack = [root]
# while len(stack) != 0:
# cur = stack.pop()
# # 访问当前结点
# print(cur.val)
# if cur.right is not None: # 先压右,那么右字数在栈下面,左子树在栈上面
# stack.append(cur.right)
# if cur.left is not None:
# stack.append(cur.left)
# 2. 二叉树的先序遍历(递归算法)
def preorder_traversal_recursion(root):
if root is None:
return
print(root.val)
preorder_traversal_recursion(root.left)
preorder_traversal_recursion(root.right)
# 3. 二叉树的中序遍历(非递归算法)
def inorder_traversal(root):
stack = []
cur = root
while len(stack) != 0 or cur is not None:
while cur is not None:
stack.append(cur)
cur = cur.left
cur = stack.pop()
print(cur.val)
cur = cur.right
# 4. 二叉树的中序遍历(递归算法)
def inorder_traversal_recursion(root):
if root is None:
return
inorder_traversal_recursion(root.left)
print(root.val)
inorder_traversal_recursion(root.right)
# 5. 二叉树的后序遍历(非递归算法)
def postorder_traversal(root):
stack = []
flags = [] # 0表示从左子树返回,继续访问右节点;1表示从右子树返回,弹出并访问当前结点
cur = root
while len(stack) != 0 or cur is not None:
while cur is not None:
stack.append(cur)
flags.append(0)
cur = cur.left
cur = stack.pop()
flag = flags.pop()
if flag == 0:
stack.append(cur)
flags.append(1)
cur = cur.right
else:
print(cur.val)
cur = None # 关键一步
# 6. 二叉树的后序遍历(递归算法)
def postorder_traversal_recursion(root):
if root is None:
return
postorder_traversal_recursion(root.left)
postorder_traversal_recursion(root.right)
print(root.val)
# 7. 二叉树的广度优先遍历(层次遍历)
def level_traversal(root):
if root is None:
return
queue = [root]
end = queue[-1]
level = 1
print("level " + str(level))
while len(queue) != 0:
cur = queue.pop(0)
print(cur.val)
if cur.left is not None:
queue.append(cur.left)
if cur.right is not None:
queue.append(cur.right)
if cur == end:
level += 1
if len(queue) != 0:
end = queue[-1]
print("level " + str(level))
def test():
# 用字符串数组来描述一颗二叉树
data = ["1", "2", "3", "NaN", "5", "6", "7"]
tree = BinaryTree()
root = tree.init_tree(data)
print("1. 先序非递归")
preorder_traversal(root)
print()
print("2. 先序递归")
preorder_traversal_recursion(root)
print()
print("3. 中序非递归")
inorder_traversal(root)
print()
print("4. 中序递归")
inorder_traversal_recursion(root)
print()
print("5. 后序非递归")
postorder_traversal(root)
print()
print("6. 后序递归")
postorder_traversal_recursion(root)
print()
print("7. 广度优先(层次遍历)")
level_traversal(root)
print()
print("8. 二叉树的深度优先遍历")
print("深度优先其实就是先序遍历")
print()
if __name__ == '__main__':
test()
首先我们构造的树是这样的:
1. 先序非递归
1
2
5
3
6
7
2. 先序递归
1
2
5
3
6
7
3. 中序非递归
2
5
1
6
3
7
4. 中序递归
2
5
1
6
3
7
5. 后序非递归
5
2
6
7
3
1
6. 后序递归
5
2
6
7
3
1
7. 广度优先(层次遍历)
level 1
1
level 2
2
3
level 3
5
6
7
8. 二叉树的深度优先遍历
深度优先其实就是先序遍历
Process finished with exit code 0