二叉树线索化 Python实现
二叉树线索化
二叉树线索化对二叉树进行线性化操作,使其每一个结点在线性化序列中有且只有一个直接前驱和直接后继,其中第一个结点直接前驱和最后一个结点直接后继置空,建立规则如下
- 若当前结点有左子树,则
left
域为左孩子,leftTag
域为False
;否则指向其直接前驱结点,leftTag
域为True
- 若当前结点有右子树,则
right
域为右孩子,rightTag
域为False
;否则指向其直接后继结点,rightTag
域为True
下述实现以二叉搜索树为例
线索化
记录之前访问的结点引用,从根结点开始,先线索化左子树,递归直到最左的结点,其左子树依然为None
,回溯到上一层,previous
更新为当前结点,递归到右子树,线索化右子树过程类似,回溯直到根结点,递归进入根结点右子树,线索化结束后即完成整棵BST
的线索化
def threading(self, node):
if node != None:
# threading the left subtree
self.threading(node.left)
if node.left == None:
# if left field is None
# left field point to previous node
node.left = self.previous
node.leftTag = True
if self.previous != None and self.previous.right == None:
# if right field of previous node is None
# which point to current node
self.previous.right = node
self.previous.rightTag = True
# update previous node to current node
self.previous = node
# threading the right subtree
self.threading(node.right)
实现代码
class Node():
'''
Description:
Node of tree
Attributes:
data:
the data of node
left:
reference of left subtree or previous node
right:
reference of right subtree or successive node
leftTag:
True, if left field is the reference of previous node
False, if left field is the reference of left subtree
rightTag:
True, if right field is the reference of successive node
False, if right field is the reference of right subtree
'''
def __init__(self, data, left, right):
self.data = data
self.left = left
self.right = right
self.leftTag = False
self.rightTag = False
class BinarySearchTree():
'''
Description:
binary search tree
Attributes:
root:
the reference of binary-search-tree root node
previous:
the reference of current node's previous node
'''
def __init__(self):
self.root = None
self.previous = None
'''
Description:
insert new node into BST according BST rules
Args:
data:
the data of new node
node:
current node reference
Returns:
reference of current node or new node
'''
def insertIntoTree(self, data, node):
if node == None:
return Node(data, None, None)
elif data > node.data:
node.right = self.insertIntoTree(data, node.right)
elif data < node.data:
node.left = self.insertIntoTree(data, node.left)
return node
'''
Description:
insert into BST, recursively
Args:
data:
the data of new node
Returns:
None
'''
def insert(self, data):
self.root = self.insertIntoTree(data, self.root)
'''
Description:
Inoder Traverse
Args:
node:
current node reference
Returns:
None
'''
def inorderTraverse(self, node):
if node.left != None:
self.inorderTraverse(node.left)
print(node.data, end = " ")
if node.right != None:
self.inorderTraverse(node.right)
'''
Description:
output the ascending sequence of BST
Args:
None
Returns:
None
'''
def ascendingSequence(self):
self.inorderTraverse(self.root)
'''
Description:
BST threading
Args:
node:
current node reference
Returns:
None
'''
def threading(self, node):
if node != None:
# threading the left subtree
self.threading(node.left)
if node.left == None:
# if left field is None
# left field point to previous node
node.left = self.previous
node.leftTag = True
if self.previous != None and self.previous.right == None:
# if right field of previous node is None
# which point to current node
self.previous.right = node
self.previous.rightTag = True
# update previous node to current node
self.previous = node
# threading the right subtree
self.threading(node.right)
'''
Description:
traverse after BST has been threaded only by the right field
Args:
None
Returns:
None
'''
def threadingTraverse(self):
node = self.root
while node.left != None:
node = node.left
while node != None:
print(node.data, end = " ")
node = node.right
if __name__ == "__main__":
binarySearchTree = BinarySearchTree()
values = [2, 0, 8, 24]
for value in values:
binarySearchTree.insert(value)
binarySearchTree.ascendingSequence()
binarySearchTree.threading(binarySearchTree.root)
print()
binarySearchTree.threadingTraverse()
测试结果
0 2 8 24
0
2
8
24
鸣谢
最后
- 由于博主水平有限,不免有疏漏之处,欢迎读者随时批评指正,以免造成不必要的误解!