# list of lists
# 在这种定义的情况下,根节点为t[0],左节点t[1],右节点为t[2]
def binary_tree(r):
return [r,[],[]]
def insert_left(root,new_branch):
t = root.pop(1) #左孩子
if len(t) > 0: # 如果左孩子不为空,将其作为新分支的左孩子
root.insert(1,[new_branch,t,[]])
else:
root.insert(1,[new_branch,[],[]])
return root
def insert_right(root,new_branch):
t = root.pop(2)
if len(t) > 0:
root.insert(2,[new_branch,[],t])
else:
root.insert(2,[new_branch,[],[]])
return root
def get_root_val(root):
return root[0]
def set_root_val(root,new_val):
root[0] = new_val
def get_left_child(root):
return root[1]
def get_right_child(root):
return root[2]
# nodes and references
# 这种思想主要是构建一个类,并采用嵌套的方法,生成左右节点
class BinaryTree:
def __init__(self,root):
self.key = root
self.left_child = None
self.right_child = None
def insert_left(self,new_node):
if self.left_child == None:
self.left_child = BinaryTree(new_node)
else:
t = BinaryTree(new_node)
t.left_child = self.left_child
self.left_child = t
def indert_right(self,new_node):
if self.right_child == None:
self.right_child = BinaryTree(new_node)
else:
t = BinaryTree(new_node)
t.right_child = self.right_child
self.right_child = t
def get_right_child(self):
return self.right_child
def get_left_child(self):
return self.left_child
def set_root_val(self,obj):
self.key = obj
def get_root_val(self):
return self.key
# 树的遍历:先序遍历(中左右) 中序遍历(左中右) 后序遍历(左右中)
# 先中后都是对于根节点来说的
# 外界函数
def preorder(tree):
if tree:
print(tree.get_root_val())
preorder(tree.get_left_child())
preorder(tree.get_right_child())
def postorder(tree):
if tree:
postorder(tree.get_left_child())
postorder(tree.get_right_child())
print(tree.get_root_val())
def inorder(tree):
if tree:
postorder(tree.get_left_child())
print(tree.get_root_val())
postorder(tree.get_right_child())
# 类中函数
def preorder_inclass(self):
print(self.key)
if self.left_child:
self.left_child.preorder_inclass()
if self.right_child:
self.right_child.preorder_inclass()
# 二叉搜索树(BST)
# 其或者是一颗空树,或者是具有以下性质的二叉树
# 若左子树不空,则左子树上所有节点的值均小于或者等于它的根节点的值
# 若右子树不空,则右子树上所有节点的值均大于或者等于它的根节点的值
# 左右子树也分别为二叉排序树
# 树中的节点定义如下
class Node:
def __init__(self,data):
self.data = data
self.lchild = None
self.rchild = None
# 搜索(外界函数)
def search(self,node,data):
if node == None:
return False
if node.data == data:
return True
if node.data > data:
return self.search(node.lchild,data)
else:
return self.search(node.rchild,data)
# 查找二叉搜索树中的最大(小)值
def findMin(self,root):
if root.lchild:
return self.findMin(root.lchild)
else:
return root.data
def findMax(self,root):
if root.rchild:
return self.findMax(root.rchild)
else:
return root.data
# 删除(类中函数)
def delete(self,data):
if not self:
return None
if data < self.data:
self.lchild = self.lchild.delete(data)
elif data > self.data:
self.rchild = self.rchild.delete(data)
else:
if self.lchild == None:
return self.rchild
elif self.rchild == None:
return self.lchild
else:
temp = self.findMin(self.rchild)
self.data = temp
self.rchild.delete(temp)
return self
# 搜索(类中函数)
def find(self,data):
if data == self.data:
return True
elif data < self.data:
if self.lchild:
return self.lchild.find(data)
else:
return False
else:
if self.rchild:
return self.rchild.find(data)
else:
return False
# 插入(类中函数)(需要return?)
def insert(self,data):
if data < self.data:
if self.lchild:
return self.lchild.insert(data)
else:
self.lchild = Node(data)
else:
if self.rchild:
return self.rchild.insert(data)
else:
self.rchild = Node(data)