数据结构 学习笔记4（AVL树）

二叉搜索树的效率

AVL树

所谓平衡的意思就是左右子树的高度相差不能超过1，我们引入平衡因子的概念，定义平衡因子数值为左边的高度减去右边的高度，所以平衡因子都为-1，0，1的树就是平衡的。有些时候也会用平衡因子 = 右子树的高度 - 左子树的高度。

AVL树——插入

AVL插入——右旋

AVL插入——左旋

AVL插入——右旋-左旋

AVL插入——左旋-右旋

旋转实现（其中BiTreeNode，BST直接用前面一节的代码）：
需要注意的是这里的代码平衡因子是右子树高度减左子树的高度。

from bst import BiTreeNode, BST

class AVLNode(BiTreeNode):
	def __init__(self, data):
		BiTreeNode.__init__(self, data)
		self.bf = 0

class AVLTree(BST):
	def __init__(self, li=None):
		BST.__init__(self, li)

	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.rchild = s2
		if s2:
			s2.parent = p
		g.lchild = p
		p.parent = g

		# 更新bf
		if g.bf > 0:	# 插入的是s3
			p.bf = -1
			c.bf = 0
		elif g.bf < 0:	# 插入的是s2
			p.bf = 0
			c.bf = 1
		else: # 插入的是g
			p.bf = 0
			c.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.lchild = s3
		if s3:
			s3.parent = p
		g.rchild = p
		p.parent = g

		# 更新bf
		if g.bf < 0:	# 插入的是s2
			p.bf = 1
			c.bf = 0
		elif g.bf > 0:	# 插入的是s3
			p.bf = 0 
			c.bf = -1
		else: # 插入的是g
			p.bf = 0
			c.bf = 0
		return g	
	def insert_no_rec(self, val):	# 没有递归的实现方式
		# 1. 和BST一样，插入
		p = self.root
		if not p:		# 空树
			self.root = AVLNode(val)
			return
		while True:
			if val < p.data:
				if p.lchild:
					p = p.lchild
				else:		# 左孩子不存在
					p.lchild = AVLNode(val)
					p.lchild.parent = p
					node = p.lchild		# node 存储的就是插入的节点
					break
			elif val > p.data:
				if p.rchild:
					p = p.rchild
				else:
					p.rchild = AVLNode(val)
					p.rchild.parent = p
					node = p.rchild
					break
			else:		# val = p.data,不允许插入相同元素
				return
		# 2. 更新balance factor
		while node.parent:		# node.parent不空
			if node.parent.lchild == node:		# 传递是从左子树来的，左子树更沉了
				# 更新node.parent的bf -= 1
				if node.parent.bf < 0:		#原来node.parent.bf == -1,更新后变成-2
					# 做旋转
					# 看node哪边沉
					g = node.parent.parent		# 为了连接旋转之后的子树
					x = node.parent		# 旋转前的子树的根
					if node.bf > 0:
						n =self.rotate_left_right(node.parent,node)
					else:
						n = self.rotate_right(node.parent,node)
					# 记得：把n和g连起来
				elif node.parent.bf > 0:		# 原来node.parent.bf = 1，更新之后变成0
					node.parent.bf = 0
					break
				else:		# 原来node.parent.bf = 0,更新之后变成-1
					node.parent.bf = -1
					node = node.parent
					continue
			else:	# 传递是从右子树来的，右子树更沉了
				# 更新node.parent.bf += 1
				if node.parent.bf > 0:	# 原来node.parent.bf == 1, 更新后变成2
					# 做旋转
					# 看node哪边沉
					g = node.parent.parent	# 为了连接旋转之后的子树
					x = node.parent		# 旋转前的子树的根
					if node.bf < 0:	# node.bf = 1
						n = self.rotate_right_left(node.parent, node)
					else:	# node.bf = -1
						n = self.rotate_left(node.parent, node)
					# 记得连起来
				elif node.parent.bf < 0:	# 原来node.parent.bf = -1,更新之后变成0
					node.parent.bf = 0
					break
				else:	# 原来node.parent.bf = 0, 更新之后变为1
					node.parent.bf = 1
					node = node.parent
					continue
					
			# 链接旋转后的子树
			n.parent = g
			if g:	# g不是空
				if x == g.lchild:
					g.lchild = n
				else:
					g.rchild = n
				break
			else:
				self.root = n
				break		

tree = AVLTree([9,8,7,6,5,4,3,2,1])
tree.pre_order(tree.root)
print("")
tree.in_order(tree.root)
				

旋转部分代码只用于插入没问题，用于删除有问题。如下图所示，由于删除引起的不平衡，左旋后平衡因子不是0.

二叉搜索树扩展应用——B树