'''
树
目录结构
可以递归定义的数据结构
'''
class Node:
def __init__(self, name, type='dir'):
self.name = name
self.type = type # 'dir' or 'file'
self.children = []
self.parent = None
def __repr__(self):
return self.name
n = Node('hello')
n2 = Node("world")
n.children.append(n2)
n2.parent = n
# 类似双链表
# 模拟操作系统
class FileSystemTree:
def __init__(self):
self.root = Node("/")
self.now = self.root
def mkdir(self, name):
# name 以/结尾
if name[-1] != '/':
name += '/'
node = Node(name)
self.now.children.append(node)
node.parent = self.now
def ls(self):
return self.now.children
def cd(self, name):
if name[-1] != '/':
name += '/'
if name == '../':
self.now = self.now.parent
return
for child in self.now.children:
if child.name == name:
self.now = child
return
raise ValueError("invalid dir")
tree = FileSystemTree()
tree.mkdir('var/')
tree.mkdir('bin/')
tree.mkdir('usr/')
tree.cd('bin/')
tree.mkdir('python/')
tree.cd('../')
print(tree.ls())
二叉树
# 二叉树
class BiTreeNode:
def __init__(self, data):
self.data = data
self.lchild = None
self.rchild = None
a = BiTreeNode('A')
b = BiTreeNode('B')
c = BiTreeNode('C')
d = BiTreeNode('D')
e = BiTreeNode('E')
f = BiTreeNode('F')
g = BiTreeNode('G')
e.lchild = a
e.rchild = g
a.rchild = c
c.lchild = b
c.rchild = d
g.rchild = f
root = e
# print(root.lchild.rchild.data)
print("\n")
# 二叉树的遍历
# 前序遍历
def pre_order(root):
if root:
print(root.data, end=',')
pre_order(root.lchild)
pre_order(root.rchild)
# pre_order(root)
'''
二叉搜索树
二叉搜索树是一颗二叉树且满足性质:设X是二叉树的一个节点。如果y是x左子树的一个节点,那么y.key<=x.key;
如果y是x右子树的一个节点,那么y.key>=x.key
二叉搜索树的操作:
查询
插入
删除
效率:
平均情况下:时间复杂度为o(lgn)
最坏情况下,二叉搜索树可能非常偏斜(向右偏斜)
解决方案:
随机化插入
'''
**
AVL树
**
'''
AVL树:一颗自平衡的二叉树
AVl树的性质:
根的左右子树的高度之差的绝对值不能超过1
根的左右子树都是平衡二叉树
AVL树 -- 插入
插入一个节点可能会破坏AVL树的平衡,可以通过旋转操作来进行修正
插入一个节点后只有从插入节点到根节点的路径上的节点的平衡可能被改变。我们需要找出第一个破坏了平衡条件的节点,称之为k.k的两颗子树的高度差为2
不平衡的出现可能有4种情况
左旋
不平衡是由于对k的右孩子的右子树插入导致的
右旋
不平衡是由于对k的左孩子的左子树插入导致的
右旋-左旋
不平衡是由于对k的右孩子的左子树插入导致的
左旋-右旋
不平衡是由于对k的左孩子的右子树插入导致的
'''
class BSTTreeNode:
def __init__(self, data):
self.data = data
self.lchild = None
self.rchild = None
self.parent = None
class BST:
def __init__(self, li=None):
self.root = None
if li:
for val in li:
self.insert_no_ret(val)
def insert(self, node, val):
if not node:
node = BSTTreeNode(val)
elif val < node.data:
node.lchild = self.insert(node.lchild, val)
elif val > BSTTreeNode(val):
node.rchild = self.insert(node.rchild, val)
node.rchild.parent = node
return node
def insert_no_ret(self, val):
p = self.root
if not p: # 空树
self.root = BSTTreeNode(val)
return
while True:
if val < p.data:
if p.lchild:
p = p.lchild
else: # 左孩子不存在
p.lchild = BSTTreeNode(val)
p.lchild.parent = p
return
elif val > p.data:
if p.rchild:
p = p.rchild
else: # 右孩子不存在
p.rchild = BSTTreeNode(val)
p.rchild.parent = p
return
else:
return
# 查询
# 递归查询
def query(self, node, val):
if not node:
return True
if node.data < val:
return self.query(node.lchild, val)
elif node.data > val:
return self.query(node.rchild, val)
else:
return node
# 非递归
def query_no_rec(self, val):
p = self.root
while p:
if p.data < val:
p = p.rchild
elif p.data > val:
p = p.lchild
else:
return p
return None
# 前序遍历
def pre_order(self, root):
if root:
print(root.data, end=',')
self.pre_order(root.lchild)
self.pre_order(root.rchild)
# 中序遍历 一定是有序数列
def in_order(self, root):
if root:
self.in_order(root.lchild)
print(root.data, end=',')
self.in_order(root.rchild)
# 后序遍历
def post_order(self, root):
if root:
self.post_order(root.lchild)
self.post_order(root.rchild)
print(root.data, end=',')
# 删除
'''
如果要删除的节点只有一个孩子;将此节点的父亲与孩子连接,然后删除该节点
如果要删除的节点是根节点,
如果要删除的节点有两个孩子;将其右子树的最小节点(该节点最多有一个右孩子)或者左子树的最大节点(该节点最多有一个左孩子)删除,并替换当前节点
'''
def __remove_node_1(self, node):
# 情况1:node是叶子结点
if not node.parent:
self.root = None
if node == node.parent.lchild: # node是它父亲的左孩子
node.parent.lchild = None
node.parent = None
else: # 右孩子
node.parent.rchild = None
node.parent = None
def __remove_node_21(self, node):
# 情况2 1:node只有一个左孩子
if not node.parent:
self.root = node.lchild
node.lchild.parent = None
elif node == node.parent.lchild:
node.parent.lchild = node.lchild
node.lchild.parent = node.parent
else:
node.parent.rchild = node.lchild
node.lchild.parent = node.parent
def __remove_node_22(self, node):
# 情况2 2:node只有一个右孩子
if not node.parent:
self.root = node.rchild
elif node == node.parent.lchild:
node.parent.lchild = node.rchild
node.rchild.parent = node.parent
else:
node.parent.rchild = node.rchild
node.rchild.parent = node.parent
def delete(self, val):
if self.root:
node = self.query_no_rec(val)
if not node: # 不存在
return False
if not node.lchild and not node.rchild:
self.__remove_node_1(node)
elif not node.rchild: # 2.1只有一个左孩子
self.__remove_node_21(node)
elif not node.lchild: # 2.2只有一个右孩子
self.__remove_node_22(node)
else:
# 3.两个孩子都有
min_node = node.rchild
while min_node.lchild:
min_node = min_node.lchild
node.data = min_node.data
# 删除min_node
if min_node.rchild:
self.__remove_node_22(node)
else:
self.__remove_node_1(min_node)
tree = BST([4, 6, 7, 9, 2, 1, 3, 5, 8])
tree.pre_order(tree.root)
print("\n----------------")
tree.in_order(tree.root)
print("\n----------------")
tree.post_order(tree.root)
print("\n----------------")
print(tree.query_no_rec(4).data)
tree.delete(4)
print("\n------------------")
tree.in_order(tree.root)
'''
AVL树的插入实现
'''
class AVTNode:
def __init__(self, data):
self.data = data
self.lchild = None
self.rchild = None
self.parent = None
self.bf = 0
class AVTTree:
def __init__(self, li=None):
self.root = None
if li:
for val in li:
self.insert_no_rec(val)
# 左旋
def rotate_left(self, p, c):
s2 = c.lchild
p.rchild = s2
if s2:
s2.parent = p
c.lchild = p
p.parent = c
p.bf = 0
c.bf = 0
return c
# 右旋
def rotate_right(self, p, c):
s2 = c.rchild
p.lchild = s2
if s2:
s2.parent = p
c.rchild = p
p.parent = c
p.bf = 0
c.bf = 0
return c
# 右旋-左旋
def rotate_right_left(self, p, c):
g = c.lchild
s3 = g.rchild
c.lchild = s3
if s3:
s3.parent = c
g.rchild = c
c.parent = g
s2 = g.lchild
p.lchild = s2
if s2:
s2.parent = p
g.lchild = p
p.parent = g
# 更新bf
if g.bf > 0:
p.bf = -1
c.bf = 0
elif g.bf < 0:
p.df = 0
c.bf = 1
else: # 插入的是g
p.bf = 0
c.bf = 0
g.bf = 0
return g
def rotate_left_right(self, p, c):
g = c.rchild
s2 = g.lchild
c.rchild = s2
if s2:
s2.parent = c
g.lchild = c
c.parent = g
s3 = g.rchild
p.rchild = s3
if s3:
s3.parent = p
g.rchild = p
p.parent = g
# 更新bf
if g.bf < 0:
p.bf = 1
c.bf = 0
elif g.bf > 0:
p.bf = 0
c.bf = -1
else:
p.bf = 0
c.bf = 0
g.bf = 0
return g
def insert_no_rec(self, val):
pass