Тестирование.

Результаты тестирования представлены в табл. 1.

Таблица 1 – Результаты тестирования

№ п/п	Входные данные	Выходные данные	Комментарии
1.	root = main.Node(4) root = main.insert(5, root) root = main.insert(7, root) root = main.insert(2, root) root = main.insert(1, root) root = main.insert(3, root) a = main.delete_max_node(root) print(a.val)	7	Проверка вставки. Верно.
2.	root = Node(5) print(diff(root))	inf	Проверка функции diff. Верно.
3.	root = main.Node(23) root.left = main.Node(15) root.right = main.Node(56) root.left.left = main.Node(43) root.left.right = main.Node(24) assert main.check(root)	ok	Проверка функции check. Верно.

Вывод.

Были реализованы основные операции АВЛ-дерева, такие как вставка, удаление и балансировка. Исходя из проведённого исследования можно заметить логарифмическую зависимость времени операции от количества элементов в структуре данных.

ПРИЛОЖЕНИЕ А ИСХОДНЫЙ КОД ПРОГРАММЫ

Название файла: main.py

class Node:

def __init__(self, val, left=None, right=None):

self.val = val

self.left = left

self.right = right

def height(node):

if node is None:

return 0

return 1 + max(height(node.left), height(node.right))

def check(node):

if node is None:

return True

if abs(height(node.left) - height(node.right)) > 1:

return False

return check(node.left) and check(node.right)

def diff(root):

min_diff = float('inf')

if root is None:

return min_diff

if root.left is not None:

min_diff = min(min_diff, abs(root.val - root.left.val))

if root.right is not None:

min_diff = min(min_diff, abs(root.val - root.right.val))

min_diff = min(min_diff, diff(root.left))

min_diff = min(min_diff, diff(root.right))

return min_diff

def balance(node):

if node is None:

return 0

else:

return height(node.left) - height(node.right)

def min_val_node(node):

if node is None or node.left is None:

return node

else:

return min_val_node(node.left)

def right_rotate(node):

a = node.left

b = a.right

a.right = node

node.left = b

node.height = 1 + max(height(node.left), height(node.right))

a.height = 1 + max(height(a.left), height(a.right))

return a

def left_rotate(node):

a = node.right

b = a.left

a.left = node

node.right = b

node.height = 1 + max(height(node.left), height(node.right))

a.height = 1 + max(height(a.left), height(a.right))

return a

def insert(val, root):

if root is None:

return Node(val)

elif val <= root.val:

root.left = insert(val, root.left)

elif val > root.val:

root.right = insert(val, root.right)

root.height = 1 + max(height(root.left), height(root.right))

balance_coefficient = balance(root)

if balance_coefficient > 1 and root.left.val > val:

return right_rotate(root)

if balance_coefficient < -1 and val > root.right.val:

return left_rotate(root)

if balance_coefficient > 1 and val > root.left.val:

root.left = left_rotate(root.left)

return right_rotate(root)

if balance_coefficient < -1 and val < root.right.val:

root.right = right_rotate(root.right)

return left_rotate(root)

return root

def delete(val, node):

if node is None:

return node

elif val < node.val:

node.left = delete(val, node.left)

elif val > node.val:

node.right = delete(val, node.right)

else:

if node.left is None and node.right is None:

temp = node

node = None

return temp

if node.left is None:

return node.right

elif node.right is None:

return node.left

rgt = min_val_node(node.right)

node.value = rgt.value

node.right = delete(rgt.value, node.right)

if node is None:

return node

node.height = 1 + max(height(node.left), height(node.right))

balance_coefficient = balance(node)

if balance_coefficient > 1 and balance(node.left) >= 0:

return right_rotate(node)

if balance_coefficient < -1 and balance(node.right) <= 0:

return left_rotate(node)

if balance_coefficient > 1 and balance(node.left) < 0:

node.left = left_rotate(node.left)

return right_rotate(node)

if balance_coefficient < -1 and balance(node.right) > 0:

node.right = right_rotate(node.right)

return left_rotate(node)

return node

def find_node(val, root):

if root is None:

return None

elif val < root.val:

return find_node(val, root.left)

elif val > root.key:

return find_node(val, root.right)

else:

return root

def find_min(root):

if root.left is not None:

return find_min(root.left)

else:

return root

def find_max(root):

if root.right is not None:

return find_max(root.right)

else:

return root

def delete_min_node(root):

node = find_min(root)

value = node.val

return delete(value, node)

def delete_max_node(root):

node = find_max(root)

value = node.val

return delete(value, node)

Название файла: test.py

import main

def test_is_balance_check():

root = main.Node(23)

root.left = main.Node(15)

root.right = main.Node(56)

root.left.left = main.Node(43)

root.left.right = main.Node(24)

assert main.check(root)

def test_one_diff():

root = main.Node(5)

assert main.diff(root) == float('inf')

def test_none_diff():

root = None

assert main.diff(root) == float('inf')

def test_five_diff():

root = main.Node(2)

root.left = main.Node(1000)

root.right = main.Node(50)

root.left.left = main.Node(20)

root.left.right = main.Node(90)

assert main.diff(root) == 48

def test_one_insert():

root = None

root = main.insert(0, root)

assert root.val == 0

def test_two_insert():

root = main.Node(9)

root = main.insert(3, root)

assert root.val == 9

assert root.left.val == 3

def test_insert_balancing():

root = main.Node(3)

root = main.insert(40, root)

root = main.insert(29, root)

root = main.insert(123, root)

root = main.insert(10, root)

root = main.insert(65, root)

root = main.insert(17, root)

assert root.val == 29

assert root.left.val == 10

assert root.right.val == 65

assert root.right.right.val == 123

assert root.right.left.val == 40

assert root.left.right.val == 17

assert root.left.left.val == 3

def test_delete_max():

root = main.Node(4)

root = main.insert(5, root)

root = main.insert(7, root)

root = main.insert(2, root)

root = main.insert(1, root)

root = main.insert(3, root)

a = main.delete_max_node(root)

assert a.val == 7

assert root.left.val == 2

assert root.right.val == 5

assert root.left.left.val == 1

assert root.left.right.val == 3

def test_delete_min():

root = main.Node(68)

root = main.insert(65, root)

root = main.insert(87, root)

root = main.insert(31, root)

root = main.insert(18, root)

a = main.delete_min_node(root)

assert a.val == 18

assert root.val == 68

assert root.left.val == 31

assert root.right.val == 87

assert root.left.right.val == 65