153 lines
3.9 KiB
Python
153 lines
3.9 KiB
Python
from node import Node, Comparable
|
|
from ranked_tree import RankedTree, RotateFunction
|
|
|
|
import logging
|
|
from typing import TypeVar, Optional
|
|
|
|
logger = logging.getLogger(__name__)
|
|
T = TypeVar("T", bound=Comparable)
|
|
|
|
|
|
def _balance_factor(node: Optional[Node[T]]) -> int:
|
|
if not node:
|
|
return 0
|
|
|
|
left, right = Node.get_rank(node.left), Node.get_rank(node.right)
|
|
return right - left
|
|
|
|
|
|
def _update_rank(node: Node[T]) -> None:
|
|
left, right = Node.get_rank(node.left), Node.get_rank(node.right)
|
|
node.rank = 1 + max(left, right)
|
|
|
|
|
|
class AVLTree(RankedTree[T]):
|
|
def is_correct_node(
|
|
self, node: Optional[Node[T]], recursive: bool = True
|
|
) -> bool:
|
|
if not node:
|
|
return True
|
|
|
|
if not (
|
|
-1 <= _balance_factor(node) <= 1
|
|
and node.rank
|
|
== 1 + max(Node.get_rank(node.left), Node.get_rank(node.right))
|
|
):
|
|
return False
|
|
|
|
return not recursive or (
|
|
self.is_correct_node(node.left)
|
|
and self.is_correct_node(node.right)
|
|
)
|
|
|
|
# region InsertRebalance
|
|
|
|
def __fix_0_child(
|
|
self,
|
|
x: Node[T],
|
|
y: Optional[Node[T]],
|
|
z: Node[T],
|
|
rotate_left: RotateFunction[T],
|
|
rotate_right: RotateFunction[T],
|
|
) -> None:
|
|
if not y or Node.difference(y) == 2:
|
|
rotate_right(z)
|
|
z.demote()
|
|
elif Node.difference(y) == 1:
|
|
rotate_left(x)
|
|
rotate_right(z)
|
|
|
|
y.promote()
|
|
x.demote()
|
|
z.demote()
|
|
|
|
def _insert_rebalance(self, x: Node[T]) -> None:
|
|
diffs = Node.differences(x.parent)
|
|
while x.parent and (diffs == (0, 1) or diffs == (1, 0)):
|
|
x.parent.promote()
|
|
x = x.parent
|
|
|
|
diffs = Node.differences(x.parent)
|
|
|
|
if not x.parent:
|
|
return
|
|
|
|
rank_difference = Node.difference(x)
|
|
if rank_difference != 0:
|
|
return
|
|
|
|
x_parent = x.parent
|
|
assert x_parent is not None
|
|
if rank_difference == 0 and x.parent.left is x:
|
|
self.__fix_0_child(
|
|
x, x.right, x_parent, self.rotate_left, self.rotate_right
|
|
)
|
|
elif rank_difference == 0 and x.parent.right is x:
|
|
self.__fix_0_child(
|
|
x, x.left, x_parent, self.rotate_right, self.rotate_left
|
|
)
|
|
|
|
# endregion InsertRebalance
|
|
|
|
# region DeleteRebalance
|
|
|
|
def __delete_rotate(
|
|
self,
|
|
x: Node[T],
|
|
y: Node[T],
|
|
leaning: int,
|
|
rotate_left: RotateFunction[T],
|
|
rotate_right: RotateFunction[T],
|
|
) -> bool:
|
|
new_root = x
|
|
|
|
factor = _balance_factor(y)
|
|
if factor in (0, leaning):
|
|
new_root = rotate_left(x)
|
|
else:
|
|
rotate_right(y)
|
|
new_root = rotate_left(x)
|
|
|
|
for n in filter(None, (new_root.left, new_root.right, new_root)):
|
|
_update_rank(n)
|
|
|
|
return factor != 0
|
|
|
|
def __delete_fixup(
|
|
self, x: Node[T], parent: Optional[Node[T]] = None
|
|
) -> bool:
|
|
factor = _balance_factor(x)
|
|
if factor == 0:
|
|
_update_rank(x)
|
|
return True
|
|
elif factor in (-1, 1):
|
|
return False
|
|
|
|
y, leaning, to_left, to_right = (
|
|
(x.right, 1, self.rotate_left, self.rotate_right)
|
|
if factor == 2
|
|
else (x.left, -1, self.rotate_right, self.rotate_left)
|
|
)
|
|
assert y
|
|
return self.__delete_rotate(
|
|
x,
|
|
y,
|
|
leaning,
|
|
to_left,
|
|
to_right,
|
|
)
|
|
|
|
def _delete_rebalance(
|
|
self, node: Optional[Node[T]], parent: Optional[Node[T]]
|
|
) -> None:
|
|
if not node and not parent:
|
|
return
|
|
|
|
if not node and parent:
|
|
node, parent = parent, parent.parent
|
|
|
|
while node and self.__delete_fixup(node, parent):
|
|
node, parent = parent, parent.parent if parent else None
|
|
|
|
# endregion DeleteRebalance
|