概述
- 先看如下的二叉树，中序遍历结果为：[8,3,10,1,14,6]
- 线索二叉树 思路：
- 梳理过程：
Python实现：线索化存储二叉树
class TreeNode(object):
def __init__(self, val=-1):
self.val = val
self.left = None
self.right = None
# 新增类型指针
# 规定：
# 如果left_type==0 表示指向的是左子树，如果是1 则表示指向前驱结点
# 如果right_type==0 表示指向的是右子树，如果是1 怎表示指向后继结点
self.left_type = 0 # 注意这里必须写0，不能写空值
self.right_type = 0
class ThreadedBinaryTree(object):
def __init__(self):
self.root = None
# 在递归进行线索化，总是保留前一个结点
self.pre = None # 为实现线索化，需要创建给指向当前结点的前驱结点指针
# 添加结点测试
def add(self, val):
node = TreeNode(val)
if self.root is None:
self.root = node
return
queue = [self.root]
while queue:
temp_node = queue.pop(0)
if temp_node.left is None:
temp_node.left = node
return
else:
queue.append(temp_node.left)
if temp_node.right is None:
temp_node.right = node
return
else:
queue.append(temp_node.right)
# 中序遍历测试
def in_order(self, node):
if node is None:
return
self.in_order(node.left)
print(node.val, end=' ')
self.in_order(node.right)
# 二叉树进行中序线索化的方法
def threaded_node(self, node): # node: 就是当前需要线索化的结点
if node is None:
return
# 先线索化左子树
self.threaded_node(node.left)
# 线索化当前结点
# 处理当前结点的前驱结点
if node.left is None: # 如果当前结点左子结点为空
node.left = self.pre # 让当前结点的左指针指向前驱结点
node.left_type = 1 # 修改当前结点的左指针类型 为 前驱结点
# 处理当前结点的后继结点
if self.pre and self.pre.right is None:
self.pre.right = node # 让前驱结点的右指针指向当前结点
self.pre.right_type = 1 # 修改前驱结点的右指针类型
self.pre = node # 每处理一个结点后，让当前结点是下一个结点的前驱结点
# 线索化右子树
self.threaded_node(node.right)
if __name__ == '__main__':
t = ThreadedBinaryTree()
# t.add(1)
# t.add(3)
# t.add(6)
# t.add(8)
# t.add(10)
# t.add(14)
# t.in_order(t.root)
# t.threaded_node(t.root)
# 手动创建结点--只是为了更好测试线索化有没有成功
t1 = TreeNode(1)
t2 = TreeNode(3)
t3 = TreeNode(6)
t4 = TreeNode(8)
t5 = TreeNode(10)
t6 = TreeNode(14)
t1.left = t2
t1.right = t3
t2.left = t4
t2.right = t5
t3.left = t6
print("原来的二叉树中序遍历为：")
t.in_order(t1)
# 线索化二叉树
t.threaded_node(t1)
# 测试：以值为10 的结点来测试
left_node = t5.left
print()
print("10 的前驱结点是：%d" % left_node.val) # 3
right_node = t5.right
print("10 的后继结点是：%d" % right_node.val) # 1
'''输出结果
原来的二叉树中序遍历为：
8 3 10 1 14 6
10 的前驱结点是：3
10 的后继结点是：1
'''
- 可以比对结果，如上图，线索化二叉树后，10的前驱结点是3，10的后继结点是1，说明我们线索化二叉树，成功，接下里就要完成：线索化存储二叉树的遍历 了↓↓↓
线索化存储二叉树的遍历
class TreeNode(object):
def __init__(self, val=-1):
self.val = val
self.left = None
self.right = None
# 新增类型指针
# 规定：
# 如果left_type==0 表示指向的是左子树，如果是1 则表示指向前驱结点
# 如果right_type==0 表示指向的是右子树，如果是1 怎表示指向后继结点
self.left_type = 0
self.right_type = 0
class ThreadedBinaryTree(object):
def __init__(self):
self.root = None
# 在递归进行线索化，总是保留前一个结点
self.pre = None # 为实现线索化，需要创建给指向当前结点的前驱结点指针
# 添加结点测试
def add(self, val):
node = TreeNode(val)
if self.root is None:
self.root = node
return
queue = [self.root]
while queue:
temp_node = queue.pop(0)
if temp_node.left is None:
temp_node.left = node
return
else:
queue.append(temp_node.left)
if temp_node.right is None:
temp_node.right = node
return
else:
queue.append(temp_node.right)
# 中序遍历测试
def in_order(self, node):
if node is None:
return
self.in_order(node.left)
print(node.val, end=' ')
self.in_order(node.right)
# 中序遍历线索化二叉树
def threaded_in_order(self, node):
if node is None:
return
temp_node = node
while temp_node:
# 循环的找到left_type=1的结点，第一个找到就是值为8的结点
# 后面随着遍历而变化，因为当left_type=1时，说明该结点是按照线索化处理后的有效结点
while temp_node.left_type == 0: # 从根结点开始向左找，找到第一个1停止
temp_node = temp_node.left
# 打印当前这个结点
print(temp_node.val, end=" ")
# 如果当前结点的右指针指向的是后继结点，就一直输出
while temp_node.right_type == 1:
# 获取到当前结点的后继结点
temp_node = temp_node.right
print(temp_node.val, end=" ")
# 如果不等于1了，就替换这个遍历的结点
temp_node = temp_node.right
# 二叉树进行中序线索化的方法
def threaded_node(self, node): # node: 就是当前需要线索化的结点
if node is None:
return
# 先线索化左子树
self.threaded_node(node.left)
# 线索化当前结点
# 处理当前结点的前驱结点
if node.left is None: # 如果当前结点左子结点为空
node.left = self.pre # 让当前结点的左指针指向前驱结点
node.left_type = 1 # 修改当前结点的左指针类型 为 前驱结点
# 处理当前结点的后继结点
if self.pre and self.pre.right is None:
self.pre.right = node # 让前驱结点的右指针指向当前结点
self.pre.right_type = 1 # 修改前驱结点的右指针类型
self.pre = node # 每处理一个结点后，让当前结点是下一个结点的前驱结点
# 线索化右子树
self.threaded_node(node.right)
if __name__ == '__main__':
# 调用add 自动创建结点
t = ThreadedBinaryTree()
'''
t.add(1)
t.add(3)
t.add(6)
t.add(8)
t.add(10)
t.add(14)
t.in_order(t.root)
t.threaded_node(t.root)
print()
t.threaded_in_order(t.root)
'''
# 手动创建结点--只是为了更好测试线索化有没有成功
t1 = TreeNode(1)
t2 = TreeNode(3)
t3 = TreeNode(6)
t4 = TreeNode(8)
t5 = TreeNode(10)
t6 = TreeNode(14)
t1.left = t2
t1.right = t3
t2.left = t4
t2.right = t5
t3.left = t6
print("原来的二叉树中序遍历为：")
t.in_order(t1)
# 线索化二叉树
t.threaded_node(t1)
# 测试：以值为10 的结点来测试
left_node = t5.left
print()
print("10 的前驱结点是：%d" % left_node.val) # 3
right_node = t5.right
print("10 的后继结点是：%d" % right_node.val) # 1
print("线索化二叉树的中序遍历结果为：")
t.threaded_in_order(t1)
''' 输出结果为：
原来的二叉树中序遍历为：
8 3 10 1 14 6
10 的前驱结点是：3
10 的后继结点是：1
线索化二叉树的中序遍历结果为：
8 3 10 1 14 6
'''
- 两次遍历的结果一致，说明我们成功了，这次实现秒就妙在，新增了类型指针，还可以用来作为新的判断条件！
