Python数据结构 —— 二叉树_python二叉树csdn

1. Node

二叉树是由若干节点构成的树，首先定义节点类

在 DataStrctures/BinNode.py 下定义 BinNode（注意 DataStructures 中要有 __init__.py）

class BinNode:
	def __init__(self, data, leftChild=None, rightChild=None):
		self.data = data
		self.leftChild = leftChild
		self.rightChild = rightChild

	def left(self):
		return self.leftChild

	def right(self):
		return self.rightChild

	def setLeft(self, tree):
		self.leftChild = tree

	def setRight(self, tree):
		self.rightChild = tree

	def isLeaf(self):
		return self.leftChild == None and self.rightChild == None
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

利用 left()，right() 可以访问左右子节点；
通过 setLeft()，setRight() 可以设置左右子节点；
调用 isLeaf() 可以判断改节点是否为叶节点（无左右子节点）

---

2. BinaryTree

接着利用 BinNode 类构建二叉树，它有以下方法：

• BinaryTree() 构造函数
• getRoot() 返回根节点
• postTravling(visitFunc) 后序遍历，使用 visitFunc 操作每一个节点的 data
• levelTraving(visitFunc) 层次遍历，使用 visitFunc 操作每一个节点的 data（需要用到队列 Queue）

from DataStructures.Queue import Queue
from DataStructures.BinNode import BinNode

class BinaryTree:
	def __init__(self, data):
		self.root = BinNode(data)

	def getRoot(self):
		return self.root

	def postTraveling(self, visitFunc):
		self.helpPost(self.root, visitFunc)
	
	# 后序遍历的辅助函数
	def helpPost(self, node, visitFunc):
		if node != None:
			self.helpPost(node.leftChild, visitFunc)
			self.helpPost(node.rightChild, visitFunc)
			visitFunc(node)

	def leverTraveling(self, visitFunc):
		q = Queue()
		if self.root != None:
			q.enqueue(self.root)
		while not q.isEmpty():
			curr = q.dequeue()
			visitFunc(curr)
			if curr.leftChild != None:
				q.enqueue(curr.leftChild)
			if curr.rightChild != None:
				q.enqueue(curr.rightChild)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

---

3. 使用二叉树

3.1 构建二叉树

二叉树的类只能初始化根节点，返回一个二叉树对象

但我们可以调用 BnNode 和 BinaryTree 类的成员方法构建二叉树（BinaryTree.getRoot(), BinNode(), BinNode.setLeft() 和 BinNode.setRight()）：

构建二叉树的时候，采用先序遍历的方式输入节点数据，每一个节点的数据为一个字符，字符为 # 代表空节点：

from DataStructures.Queue import Queue
from DataStructures.BinNode import BinNode

class BinaryTree:
	def __init__(self, data):
		self.root = BinNode(data)

	def getRoot(self):
		return self.root
	
	# 后序遍历
	def postTraveling(self, visitFunc):
		self.helpPostTraveling(self.root, visitFunc)
	
	def helpPostTraveling(self, node, visitFunc):
		if node != None:
			self.helpPostTraveling(node.leftChild, visitFunc)
			self.helpPostTraveling(node.rightChild, visitFunc)
			visitFunc(node)
	
	# 中序遍历
	def midTraveling(self, visitFunc):
		self.helpMidTraveling(self.getRoot(), visitFunc)
	
	def helpMidTraveling(self, node, visitFunc):
		if node != None:
			self.helpMidTraveling(node.leftChild, visitFunc)
			visitFunc(node)
			self.helpMidTraveling(node.rightChild, visitFunc)

	# 层次遍历
	def leverTraveling(self, visitFunc):
		q = Queue()
		if self.root != None:
			q.enqueue(self.root)
		while not q.isEmpty():
			curr = q.dequeue()
			visitFunc(curr)
			if curr.leftChild != None:
				q.enqueue(curr.leftChild)
			if curr.rightChild != None:
				q.enqueue(curr.rightChild)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

加入要构建下面的二叉树

则需要调用 createBinaryTree 后输入：

Input data by pre order, "#" represent empty node:
>> 3
>> 2
>> #
>> #
>> 1
>> #
>> #
1
2
3
4
5
6
7
8

---

3.2 后序遍历、中序遍历和层次遍历

为了测试成功构建了二叉树，现在对二叉树遍历：
（后序遍历 + 中序遍历 或 后序遍历 + 前序遍历 可以确定一颗二叉树）

tree = createBinaryTree()
visitFunc = lambda node : print(node.data, end=' ')
print('\n后序遍历：', end='')
tree.postTraveling(visitFunc)
print('\n中序遍历：', end='')
tree.midTraveling(visitFunc)
print('\n层次遍历：', end='')
tree.leverTraveling(visitFunc)
1
2
3
4
5
6
7
8

其中，visitFunc 函数定义了对每一个节点元素进行打印操作，执行结果如下：

后序遍历：1 2 6 5 4 3 
中序遍历：2 1 3 4 6 5 
层次遍历：3 2 4 1 5 6 
1
2
3

与预期结果一致