python数据结构教程第四课
树形结构是复杂结构中最简单的一类，这是一类非常重要的结构，在实际中使用广泛，反映了许多计算过程的抽象结构
一、简介
1.树
2.二叉树
二、二叉树和树的抽象数据类型（ADT）
三、二叉树的python实现
1.二叉树的list实现
2.二叉树的遍历操作
3.二叉树的链表实现
四、二叉树的应用——Huffman Tree
五、树的python实现
一、简介
二叉树是树的子集，具有树的全部特性，这里先介绍树的定义与基本特性
1.树
定义：一棵树是n(n>=0)个结点的有限集T，当T非空时满足：
1）T中有且仅有一个特殊结点r称为树T的根
2）除根结点外的其余结点分为m(m>=0)个互不相交的非空有限子集，每个集合为一棵非空树，称为r的子树
结点个数为0的树称为空树
树的特性：
1）如果树的结构不空，其中就存在着唯一的起始结点，称为树根
2）按结构的连接关系，树根外的其余结点都有且只有一个前驱，但另一方面，一个结点可以有0个或者多个后继。在非空的树结构中一定有一些结点并不连接到其他结点，与尾结点相似
3）从树根结点出发，经过若干次后继关系可以到达结构中的任意一点
4）结点之间的联系不会形成循环关系
5）从这个结构里的任意两个不同结点出发，通过后继关系可达的两个结点集合，或者互不相交，或者一个是另一个的子集
2.二叉树
定义：二叉树是结点的有穷集合。这个集合或者是空集，或者其中有一个称为根结点的特殊结点，其余结点分属两棵不相交的二叉树，这两棵二叉树分别是原二叉树的左子树和右子树
关于二叉树的一些基本概念：
1）一棵二叉树的根结点称为该树的子树根结点的父结点；与此对应，子树的根结点称为二叉树树根结点的子结点
2）从父结点到子结点有一条连线，称为从父结点到子结点的边，父结点的两个结点互为兄弟结点
3）在二叉树里有些结点的两棵子树都空，没有子结点，这种结点称为树叶，树中其余结点称为分支结点
4）一个结点的子结点个数称为该结点的度数。显然，二叉树中树叶结点的度数为0，分支结点的度数可以是1或2
二、二叉树和树的抽象数据类型（ADT）
二叉树的基本操作包括创建空树，设置左右子树等，其基本ADT如下：
ADT BTree：
BTree(self, data, left,right) #构造空树
is_empty(self) #空树判断
num_nodes(self) #返回结点树
data(self) #返回树根数据
left(self) #返回左子树
right(self) #返回右子树
set_left(self) #设置左子树
set_right() #设置右子树
traversal(self) #迭代器
forall(self,op) #op的遍历操作
树的抽象数据类型与二叉树类似，不过在具体实现时，实现策略会有所不同，这里先给出ADT：
ADT Tree:
Tree(self, data,forest) #树的初始化
is_empty(self) #空树判断
num_nodes(self) #返回结点数据
data(self) #返回树根中的数据
first_child(self,node) #取得node的第一棵子树
children(self,node) #结点node子树的迭代器
set_first(self,tree) #用tree取代第一棵子树
insert_child(self, i,tree) #设置第i棵子树
traversal(self) #所有结点的迭代器
forall(self,op) #op的遍历操作
本文会着重介绍二叉树的实现方法和操作，由于篇幅问题对于树的实现只做简单的策略介绍，感兴趣的同学可以等待我以后另开博客讲解
三、二叉树的python实现
1.二叉树的list实现
思考可以发现，二叉树的一个结点其实就是一个三元组，分别存储着数据和左右子树，因此这里给出一个简单的list二叉树实现方式（也可以用tuple实现，区别只是在于list可以改变）
采用嵌套括号的形式，可以将二叉树表示为：
['A',['B',None,None],
['C',['D',['F',None,None],
['G',None,None]],
['E',['I',None,None],
['H',None,None]]]]
由上，我们来定义一组函数，描述二叉树的基本构造与方法，其具体的类实现，会在介绍了二叉树的遍历之后，使用链表方法实现
def BTree(data,left=None,right = None):
return [data,left,right]
def is_empt_BTree(btree):
return btree is None
def root(btree):
return btree[0]
def left(btree):
return btree[1]
def right(btree):
return btree[2]
def set_root(btree,data):
btree[0] = data
def set_left(btree,data):
btree[1] = data
def set_right(btree,data):
btree[2] = data
定义一个二叉树的源码为：
t1 = BTree(2,BTree(4),BTree(8))
2.二叉树的遍历
二叉树的结构比较复杂，因此系统化遍历有许多种可能的方式，以根为起点，存在两种基本方式：
1）深度优先遍历，顺着一条路径尽可能向前搜索，必要时回朔。对于二叉树，最基本的回朔情况是检查完一个结点，由于无路可走便回头
2）宽度优先遍历，在所有路径上齐头并进
按深度优先遍历需要做三件事情：遍历左子树、遍历右子树和访问根结点，选择这三项工作不同的执行顺序，就可以得到三种常见的遍历顺序：先根序遍历、中根序遍历、后根序遍历；对二叉树做宽度优先遍历，就是按二叉树的层次逐层访问树中的各结点，常见的是在每一层从左往右逐个访问
下面给出先根序遍历二叉树的递归函数：
#先给出二叉树结点类的定义
class BNode:
def __init__(self,data,left = None,right = None):
self._data = data
self._left = left
self._right = right
def data(self):
if self is None:
return None
else:
return self._data
def left(self):
if self is None:
return None
else:
return self._left
def right(self):
if self is None:
return None
else:
return self._right
def set_data(self,data):
self._data = data
def set_left(self,left):
self._left = left
def set_right(self,right):
self._right = right
def __eq__(self,another):
if self is None:
return another == None
if another is None:
return self is None
else:
return self._data == another.data() and self._left == another.left() and self._right == another.right()
#递归遍历，先根序,proc是对结点中元素的操作
def preorder(t,proc):
if t is None:
return
proc(t.data())
preorder(t.left())
preorder(t.right())
测试函数
#使用了上述递归算法思想的二叉树输出函数
def print_BNode(t):
if t is None:
print('^',end = '')
return
print('(' + str(t.data()),end = '')
print_BNode(t.left())
print_BNode(t.right())
print(')',end='')
t = BNode(1,BNode(2,BNode(5)),BNode(3))
print_BNode(t)
结果
(1(2(5^^)^)(3^^))
下面给出宽度优先遍历的二叉树遍历函数：
def levelorder(t,proc):
qu = SQueue()
qu.enqueue(t)
while not qu.is_empty():
t = qu.dequeue()
if t is None: #弹出的树为空则直接跳过
continue
qu.enqueue(t.left())
qu.enqueue(t.right())
proc(t.data())
当我们使用非递归算法实现二叉树的遍历时，算法的过程和结构会更加清晰，这里仅给出先根序遍历的非递归算法
def preorder_nonrec(t,proc):
s = SStack()
while t is not None or not s.is_empty():
while t is not None:
proc(t.data())
s.push(t.right())
t = t.left()
t = s.pop()
3.二叉树的链表实现
在熟悉了二叉树的遍历算法之后，我们便可以较为完整利用链表实现二叉树类，二叉树的结点继续使用前面的结点类，没有任何问题
#二叉树的基本链表实现类定义
class BTree:
def __init__(self,data,left = None,right = None):
if data == None:
self._root = None
self._num = 0
else:
self._root = BNode(data,left,right)
self._num = 1
#空链表判断
def is_empty(self):
return self._num == 0
#获得根结点中的数据
def root(self):
if self.is_empty():
return None
else:
return self._root.data()
#获得根结点的左子树
def left(self):
if self.is_empty():
return None
else:
return self._root.left()
#获得根结点的右子树
def right(self):
if self.is_empty():
return None
else:
return self._root.right()
#设置根结点的根
def set_root(self,root):
self._root = root
#设置根结点的左子树
def set_left(self,left):
self._root.set_left(left)
#设置根结点的右子树
def set_right(self,right):
self.set_right(right)
#先根序遍历方法
def preorder_elements(self):
t,s = self._root,SStack()
while t is not None or not s.is_empty():
while t is not None:
s.push(t.right())
yield t.data()
t = t.left()
t = s.pop()
#层次序遍历方法
def levelorder(self):
qu = SQueue()
qu.enqueue(self._root)
while not qu.is_empty():
t = qu.dequeue()
if t is None:
continue
qu.enqueue(t.left())
qu.enqueue(t.right())
yield t.data()
#两棵树的结构数据都相等时，两棵树相等
def __eq__(self,another):
def preorder_node(Tree):
t,s = Tree._root,SStack()
while t is not None or not s.is_empty():
while t is not None:
s.push(t.right())
yield t
t = t.left()
t = s.pop()
lt1 = []
lt2 = []
for i in preorder_node(self):
lt1.append(i)
for i in preorder_node(another):
lt2.append(i)
if len(lt1) != len(lt2):
return False
i = 0
while i < len(lt1):
if lt1[i] != lt2[i]:
return False
return True
#返回克隆树
def clone(self):
return copy.deepcopy(self)
#分别返回根结点和分支结点的数目
def count_nodes(self):
def preorder_node(Tree):
t,s = Tree._root,SStack()
while t is not None or not s.is_empty():
while t is not None:
s.push(t.right())
yield t
t = t.left()
t = s.pop()
count_leaf = 0
count_nleaf = 0
for i in preorder_node(self):
if i.left() == None and i.right() == None:
count_leaf += 1
else:
count_nleaf += 1
return count_leaf,count_nleaf
#输出树的所有结点
def printall(self):
for i in self.preorder_elements():
print(i,end = ' ')
测试代码
T = BTree(10,BNode(3,BNode(6)),BNode(5))
for i in T.levelorder():
print(i,end = ' ')
T2 = BTree(10,BNode(4,BNode(6)),BNode(5))
print()
print(T == T2)
print(T.count_nodes())
结果
10 3 5 6
False
(2, 2)
四、二叉树的应用——Huffman Tree
Huffman Tree（哈夫曼树），哈夫曼树是信息领域重要的算法，这里首先给出哈夫曼树的定义：
设有实数集W={w0,w1,…,wm-1},T是一棵扩充二叉树，其m个外部结点分别以wi为权，而且T的带权外部路径长度WPL在所有这样的扩充二叉树中达到最小，则称T为数据集W的最优二叉树或者哈夫曼树
哈夫曼提出了一种算法，可以从任意的实数集中构造出与之对应的哈夫曼树，这个构造算法如下：
1）算法的输入为实数集W={w0,w1,…wm-1}
2）在构造中维护一个包含K棵二叉树的集合F，开始时k=m且F={T0,T1,…,Tm-1}，其中每个Ti是一棵只包含权为wi的根结点的单点二叉树
3）在算法的过程中重复执行下面两个步骤，直到集合F中剩下一棵树为止：
构造一棵新二叉树，其左右子树是从集合F中选取的两棵权最小的二叉树，其根结点的权值设置为这两棵子树的根结点的权值之和；
将所选的两棵二叉树从F中删除，把新构造的二叉树加入F
下面给出哈夫曼树的实现算法：
#哈夫曼树结点类
class HTNode(BNode):
def __lt__(self,othernode):
return self.data() < other.data()
#哈夫曼树中需要的优先队列
class HuffmanPrioQ(PrioQueue):
def number(self):
return len(self._elems)
#哈夫曼树构造算法
def HuffmanTree(weights):
trees = HuffmanPrioQ()
for w in weights:
trees.enqueue(HTNode(w))
while trees.number() > 1:
t1 = trees.dequeue()
t2 = trees.dequeue()
x = t1.data() + t2.data()
trees.enqueue(HTNode(x,t1,t2))
return trees.dequeue()
五、树的python实现
树的结构相对于二叉树来比较复杂，其实现方式也多种多样，比如子结点引用表示法、子结点表表示法、长子-兄弟表示法等，这里仅介绍一种较为简单的子结点引用法
树的最基本表示方法是子结点引用法，其基本设计与二叉树的链接表示法类似：用一个数据单元表示结点，通过结点间的链接表示树结构，通过结点间的链接表示树结构。但这里有一个麻烦：树的结点度数不确定，而且结点的度数差可能很大，在这种情况下，一种简单的考虑是只支持度数不超过固定m的树，也就是说，树中分支结点至多允许m棵子树，其具体的类实现方法与二叉树的类实现方法类似，这里不给出具体的源代码