[1] zad 1
This commit is contained in:
parent
f95819cb5b
commit
bb1eebe572
292
BobrovKN/zadanie/zad 1/1.py
Normal file
292
BobrovKN/zadanie/zad 1/1.py
Normal file
|
|
@ -0,0 +1,292 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
# -*- coding: utf-8 -*-
|
||||||
|
|
||||||
|
import time
|
||||||
|
import random
|
||||||
|
import csv
|
||||||
|
import sys
|
||||||
|
sys.setrecursionlimit(30000)
|
||||||
|
|
||||||
|
def ll_create_node(name, phone):
|
||||||
|
return {'name': name, 'phone': phone, 'next': None}
|
||||||
|
|
||||||
|
def ll_insert(head, name, phone):
|
||||||
|
if head is None:
|
||||||
|
return ll_create_node(name, phone)
|
||||||
|
|
||||||
|
if head['name'] == name:
|
||||||
|
head['phone'] = phone
|
||||||
|
return head
|
||||||
|
|
||||||
|
current = head
|
||||||
|
while current['next'] is not None:
|
||||||
|
if current['next']['name'] == name:
|
||||||
|
current['next']['phone'] = phone
|
||||||
|
return head
|
||||||
|
current = current['next']
|
||||||
|
|
||||||
|
current['next'] = ll_create_node(name, phone)
|
||||||
|
return head
|
||||||
|
|
||||||
|
def ll_find(head, name):
|
||||||
|
current = head
|
||||||
|
while current is not None:
|
||||||
|
if current['name'] == name:
|
||||||
|
return current['phone']
|
||||||
|
current = current['next']
|
||||||
|
return None
|
||||||
|
|
||||||
|
def ll_delete(head, name):
|
||||||
|
if head is None:
|
||||||
|
return None
|
||||||
|
|
||||||
|
if head['name'] == name:
|
||||||
|
return head['next']
|
||||||
|
|
||||||
|
current = head
|
||||||
|
while current['next'] is not None:
|
||||||
|
if current['next']['name'] == name:
|
||||||
|
current['next'] = current['next']['next']
|
||||||
|
return head
|
||||||
|
current = current['next']
|
||||||
|
|
||||||
|
return head
|
||||||
|
|
||||||
|
def ll_list_all(head):
|
||||||
|
records = []
|
||||||
|
current = head
|
||||||
|
while current is not None:
|
||||||
|
records.append((current['name'], current['phone']))
|
||||||
|
current = current['next']
|
||||||
|
records.sort(key=lambda x: x[0])
|
||||||
|
return records
|
||||||
|
|
||||||
|
def hash_function(name, table_size):
|
||||||
|
return sum(ord(c) for c in name) % table_size
|
||||||
|
|
||||||
|
def ht_create_table(size=2000):
|
||||||
|
return [None] * size
|
||||||
|
|
||||||
|
def ht_insert(table, name, phone):
|
||||||
|
index = hash_function(name, len(table))
|
||||||
|
table[index] = ll_insert(table[index], name, phone)
|
||||||
|
|
||||||
|
def ht_find(table, name):
|
||||||
|
index = hash_function(name, len(table))
|
||||||
|
return ll_find(table[index], name)
|
||||||
|
|
||||||
|
def ht_delete(table, name):
|
||||||
|
index = hash_function(name, len(table))
|
||||||
|
table[index] = ll_delete(table[index], name)
|
||||||
|
|
||||||
|
def ht_list_all(table):
|
||||||
|
all_records = []
|
||||||
|
for bucket in table:
|
||||||
|
if bucket is not None:
|
||||||
|
current = bucket
|
||||||
|
while current is not None:
|
||||||
|
all_records.append((current['name'], current['phone']))
|
||||||
|
current = current['next']
|
||||||
|
all_records.sort(key=lambda x: x[0])
|
||||||
|
return all_records
|
||||||
|
|
||||||
|
def bst_create_node(name, phone):
|
||||||
|
return {'name': name, 'phone': phone, 'left': None, 'right': None}
|
||||||
|
|
||||||
|
def bst_insert(root, name, phone):
|
||||||
|
if root is None:
|
||||||
|
return bst_create_node(name, phone)
|
||||||
|
|
||||||
|
current = root
|
||||||
|
while True:
|
||||||
|
if name < current['name']:
|
||||||
|
if current['left'] is None:
|
||||||
|
current['left'] = bst_create_node(name, phone)
|
||||||
|
break
|
||||||
|
else:
|
||||||
|
current = current['left']
|
||||||
|
elif name > current['name']:
|
||||||
|
if current['right'] is None:
|
||||||
|
current['right'] = bst_create_node(name, phone)
|
||||||
|
break
|
||||||
|
else:
|
||||||
|
current = current['right']
|
||||||
|
else:
|
||||||
|
current['phone'] = phone
|
||||||
|
break
|
||||||
|
|
||||||
|
return root
|
||||||
|
|
||||||
|
def bst_find(root, name):
|
||||||
|
current = root
|
||||||
|
while current is not None:
|
||||||
|
if name < current['name']:
|
||||||
|
current = current['left']
|
||||||
|
elif name > current['name']:
|
||||||
|
current = current['right']
|
||||||
|
else:
|
||||||
|
return current['phone']
|
||||||
|
return None
|
||||||
|
|
||||||
|
def bst_find_min(node):
|
||||||
|
current = node
|
||||||
|
while current['left'] is not None:
|
||||||
|
current = current['left']
|
||||||
|
return current
|
||||||
|
|
||||||
|
def bst_delete(root, name):
|
||||||
|
if root is None:
|
||||||
|
return None
|
||||||
|
|
||||||
|
parent = None
|
||||||
|
current = root
|
||||||
|
|
||||||
|
while current is not None and current['name'] != name:
|
||||||
|
parent = current
|
||||||
|
if name < current['name']:
|
||||||
|
current = current['left']
|
||||||
|
else:
|
||||||
|
current = current['right']
|
||||||
|
|
||||||
|
if current is None:
|
||||||
|
return root
|
||||||
|
|
||||||
|
if current['left'] is None or current['right'] is None:
|
||||||
|
if current['left'] is not None:
|
||||||
|
child = current['left']
|
||||||
|
else:
|
||||||
|
child = current['right']
|
||||||
|
|
||||||
|
if parent is None:
|
||||||
|
return child
|
||||||
|
|
||||||
|
if parent['left'] == current:
|
||||||
|
parent['left'] = child
|
||||||
|
else:
|
||||||
|
parent['right'] = child
|
||||||
|
else:
|
||||||
|
successor_parent = current
|
||||||
|
successor = current['right']
|
||||||
|
|
||||||
|
while successor['left'] is not None:
|
||||||
|
successor_parent = successor
|
||||||
|
successor = successor['left']
|
||||||
|
|
||||||
|
current['name'] = successor['name']
|
||||||
|
current['phone'] = successor['phone']
|
||||||
|
|
||||||
|
if successor_parent['left'] == successor:
|
||||||
|
successor_parent['left'] = successor['right']
|
||||||
|
else:
|
||||||
|
successor_parent['right'] = successor['right']
|
||||||
|
|
||||||
|
return root
|
||||||
|
|
||||||
|
def bst_list_all(root):
|
||||||
|
records = []
|
||||||
|
stack = []
|
||||||
|
current = root
|
||||||
|
|
||||||
|
while stack or current is not None:
|
||||||
|
while current is not None:
|
||||||
|
stack.append(current)
|
||||||
|
current = current['left']
|
||||||
|
current = stack.pop()
|
||||||
|
records.append((current['name'], current['phone']))
|
||||||
|
current = current['right']
|
||||||
|
|
||||||
|
return records
|
||||||
|
|
||||||
|
def generate_data(n=10000):
|
||||||
|
records = [(f"User_{i:05d}", f"+7-999-{i:06d}") for i in range(n)]
|
||||||
|
records_shuffled = records.copy()
|
||||||
|
random.shuffle(records_shuffled)
|
||||||
|
records_sorted = sorted(records, key=lambda x: x[0])
|
||||||
|
return records_shuffled, records_sorted
|
||||||
|
|
||||||
|
def run_experiment(structure_name, insert_func, find_func, delete_func,
|
||||||
|
list_all_func, init_func, records, n_find=100):
|
||||||
|
|
||||||
|
data = init_func()
|
||||||
|
names = [r[0] for r in records]
|
||||||
|
|
||||||
|
start = time.perf_counter()
|
||||||
|
for name, phone in records:
|
||||||
|
if structure_name == "HashTable":
|
||||||
|
insert_func(data, name, phone)
|
||||||
|
else:
|
||||||
|
data = insert_func(data, name, phone)
|
||||||
|
insert_time = time.perf_counter() - start
|
||||||
|
|
||||||
|
find_names = random.sample(names, min(n_find, len(names)))
|
||||||
|
missing_names = [f"None_{i}" for i in range(10)]
|
||||||
|
all_find_names = find_names + missing_names
|
||||||
|
|
||||||
|
start = time.perf_counter()
|
||||||
|
for name in all_find_names:
|
||||||
|
if structure_name == "HashTable":
|
||||||
|
find_func(data, name)
|
||||||
|
else:
|
||||||
|
find_func(data, name)
|
||||||
|
find_time = time.perf_counter() - start
|
||||||
|
|
||||||
|
delete_names = random.sample(names, min(50, len(names)))
|
||||||
|
start = time.perf_counter()
|
||||||
|
for name in delete_names:
|
||||||
|
if structure_name == "HashTable":
|
||||||
|
delete_func(data, name)
|
||||||
|
else:
|
||||||
|
data = delete_func(data, name)
|
||||||
|
delete_time = time.perf_counter() - start
|
||||||
|
|
||||||
|
return insert_time, find_time, delete_time
|
||||||
|
|
||||||
|
def main():
|
||||||
|
print("Generating test data...")
|
||||||
|
records_shuffled, records_sorted = generate_data(10000)
|
||||||
|
|
||||||
|
results = []
|
||||||
|
|
||||||
|
structures = [
|
||||||
|
("LinkedList", ll_insert, ll_find, ll_delete, ll_list_all, lambda: None),
|
||||||
|
("HashTable", ht_insert, ht_find, ht_delete, ht_list_all, lambda: ht_create_table(2000)),
|
||||||
|
("BST", bst_insert, bst_find, bst_delete, bst_list_all, lambda: None)
|
||||||
|
]
|
||||||
|
|
||||||
|
for mode_name, records in [("random", records_shuffled), ("sorted", records_sorted)]:
|
||||||
|
print(f"\nMode: {mode_name}")
|
||||||
|
|
||||||
|
for struct_name, insert_f, find_f, delete_f, list_f, init_f in structures:
|
||||||
|
print(f" Testing {struct_name}...")
|
||||||
|
|
||||||
|
times = []
|
||||||
|
for run in range(5):
|
||||||
|
insert_t, find_t, delete_t = run_experiment(
|
||||||
|
struct_name, insert_f, find_f, delete_f, list_f, init_f, records
|
||||||
|
)
|
||||||
|
times.append((insert_t, find_t, delete_t))
|
||||||
|
print(f" Run {run+1}: insert={insert_t:.4f}s, find={find_t:.4f}s, delete={delete_t:.4f}s")
|
||||||
|
|
||||||
|
avg_insert = sum(t[0] for t in times) / 5
|
||||||
|
avg_find = sum(t[1] for t in times) / 5
|
||||||
|
avg_delete = sum(t[2] for t in times) / 5
|
||||||
|
|
||||||
|
results.append([struct_name, mode_name, "insert", avg_insert])
|
||||||
|
results.append([struct_name, mode_name, "find", avg_find])
|
||||||
|
results.append([struct_name, mode_name, "delete", avg_delete])
|
||||||
|
|
||||||
|
with open("results.csv", "w", newline="", encoding="utf-8") as f:
|
||||||
|
writer = csv.writer(f)
|
||||||
|
writer.writerow(["Structure", "Mode", "Operation", "Time_seconds"])
|
||||||
|
writer.writerows(results)
|
||||||
|
|
||||||
|
print("\n" + "="*60)
|
||||||
|
print("RESULTS (average over 5 runs):")
|
||||||
|
print("="*60)
|
||||||
|
for row in results:
|
||||||
|
print(f"{row[0]:12} | {row[1]:8} | {row[2]:8} | {row[3]:.6f} sec")
|
||||||
|
|
||||||
|
print("\nResults saved to results.csv")
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
main()
|
||||||
122
BobrovKN/zadanie/zad 1/otchet1.txt
Normal file
122
BobrovKN/zadanie/zad 1/otchet1.txt
Normal file
|
|
@ -0,0 +1,122 @@
|
||||||
|
|
||||||
|
|
||||||
|
Методы Программирования
|
||||||
|
|
||||||
|
|
||||||
|
Структуры данных,
|
||||||
|
анализ 1 задания
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
Бобров К. Н.
|
||||||
|
425 группа
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
Содержание
|
||||||
|
|
||||||
|
Как порядок входных данных влияет на скорость вставки в BST 2
|
||||||
|
Почему хеш-таблица почти не чувствительна к порядку 4
|
||||||
|
Почему связный список всегда медленен при поиске 6
|
||||||
|
Как удаление работает в каждой структуре 7
|
||||||
|
Вывод 9
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
Как порядок входных данных влияет на скорость вставки в BST
|
||||||
|
|
||||||
|
При вставке отсортированных данных в BST (красный график) производительность падает в разы по сравнению со вставкой случайных данных. Это связано с тем, что отсортированная последовательность приводит к вырождению дерева в связанный список, тогда как случайный порядок вставки помогает сохранять дерево относительно сбалансированным.
|
||||||
|
При вставке элементов в отсортированном порядке (по возрастанию или убыванию):
|
||||||
|
?Каждый новый элемент всегда больше (или меньше) всех уже добавленных.
|
||||||
|
?В результате алгоритм каждый раз движется по одному и тому же направлению — только в правое или только в левое поддерево.
|
||||||
|
?Из-за этого дерево вырождается: каждый узел имеет не более одного потомка, структура напоминает линейный список.
|
||||||
|
?Высота такого дерева становится пропорциональной O(n).
|
||||||
|
?Каждая операция вставки требует в среднем O(n) сравнений, так как нужно проходить всю длину текущей цепочки от корня до самого глубокого листа.
|
||||||
|
?В итоге суммарная сложность вставки всех n элементов вырастает до O(n^2).
|
||||||
|
|
||||||
|
|
||||||
|
При случайной вставке:
|
||||||
|
?Элементы распределяются по дереву гораздо равномернее.
|
||||||
|
?Высока вероятность того, что дерево останется сбалансированным.
|
||||||
|
?Средняя высота дерева сохраняется на уровне O(logn).
|
||||||
|
?Каждая операция вставки в среднем требует O(logn) сравнений.
|
||||||
|
?Общая сложность вставки всех n элементов составляет O(nlogn).
|
||||||
|
Вывод: разница в скорости объясняется различием в высоте дерева. В вырожденном случае высота равна O(n), и каждая вставка выполняется в ?n/logn раз медленнее по числу шагов, чем в сбалансированном случае с высотой O(logn).
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
Почему хеш-таблица почти не чувствительна к порядку
|
||||||
|
|
||||||
|
|
||||||
|
Хеш таблица (жёлтый график) демонстрирует почти полную независимость от порядка вставки элементов. Это объясняется тем, что положение каждого элемента в структуре определяется исключительно значением его хеш функции, а не тем, в какой последовательности происходило добавление данных.
|
||||||
|
|
||||||
|
Основные причины нечувствительности к порядку вставки:
|
||||||
|
?Хеширование. Для каждого ключа вычисляется хеш код, который преобразуется в индекс ячейки. Один и тот же ключ всегда даёт один и тот же индекс независимо от того, когда и в каком порядке он был добавлен.
|
||||||
|
?Независимость операций. Вставка, поиск и удаление выполняются в среднем за O(1)O(1), поскольку алгоритм сразу вычисляет нужную позицию, не обходя структуру и не учитывая историю добавлений.
|
||||||
|
?Разрешение коллизий. Даже если порядок вставки влияет на расположение элементов внутри цепочки (метод цепочек) или на последовательность проб (открытая адресация), это касается лишь небольших групп элементов с одинаковыми хешами. Общая производительность остаётся стабильной.
|
||||||
|
?Рехеширование. При увеличении размера таблицы все элементы перераспределяются заново. Новый порядок определяется актуальной хеш-функцией и размером таблицы, а не исходной последовательностью вставки.
|
||||||
|
Итог: Время выполнения операций зависит от качества хеш-функции, коэффициента заполнения таблицы и метода разрешения коллизий, но не зависит от порядка добавления элементов.
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
Почему связный список всегда медленен при поиске
|
||||||
|
|
||||||
|
Связный список показывает низкую скорость поиска из-за необходимости последовательного обхода: чтобы найти элемент, требуется пройти по указателям от головы до нужного узла.
|
||||||
|
Почему это происходит:
|
||||||
|
?Отсутствие произвольного доступа. В отличие от массива, где доступ по индексу занимает O(1), в связном списке элементы приходится перебирать последовательно, что даёт сложность поиска O(n).
|
||||||
|
?Низкая локальность данных. Узлы списка разбросаны по памяти случайным образом. Это вызывает частые промахи кэша: процессор не может подгрузить блок соседних данных, и каждый переход по указателю оборачивается новым обращением к оперативной памяти.
|
||||||
|
?Дополнительная память на указатели. Каждый узел хранит не только полезные данные, но и указатель на следующий элемент. Это увеличивает объём памяти и ухудшает эффективность кэша — на те же данные приходится загружать больше информации.
|
||||||
|
?Затраты на разыменование указателей. На каждом шаге поиска процессору нужно:
|
||||||
|
oпрочитать текущий узел,
|
||||||
|
oизвлечь из него указатель на следующий,
|
||||||
|
oперейти по этому адресу.
|
||||||
|
Эти операции замедляют работу по сравнению с простым сдвигом индекса в массиве.
|
||||||
|
Итог: хотя алгоритмическая сложность обхода составляет O(n) как для массива (при линейном поиске), так и для связного списка, на практике список работает ощутимо медленнее из-за особенностей организации памяти и работы кэша.
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
Как удаление работает в каждой структуре
|
||||||
|
|
||||||
|
1. Связный список
|
||||||
|
Односвязный список: чтобы удалить узел, необходимо сначала найти предыдущий элемент и перенаправить его указатель next на узел, следующий за удаляемым. Исключение — удаление первого элемента: достаточно сдвинуть указатель head на второй узел.
|
||||||
|
Двусвязный список: удаление проще, поскольку у каждого узла есть указатели и на следующий (next), и на предыдущий (prev). При удалении обновляются ссылки обоих соседей: prev->next = next, next->prev = prev.
|
||||||
|
Сложность: в общем случае O(n) из-за необходимости поиска элемента; удаление головы или хвоста (при наличии прямой ссылки на хвост) выполняется за O(1).
|
||||||
|
2. Хеш таблица
|
||||||
|
Сначала через хеш-функцию h(key) вычисляется индекс ячейки. Дальнейшие действия зависят от метода разрешения коллизий:
|
||||||
|
?Раздельная цепочка: элемент удаляется из связного списка (или другой структуры), находящегося по вычисленному индексу.
|
||||||
|
?Открытая адресация: ячейка помечается специальным маркером «удалён», а не просто как пустая — это важно для корректности последующих операций поиска.
|
||||||
|
Сложность: в среднем O(1), в худшем случае O(n) (при большом количестве коллизий).
|
||||||
|
3. Двоичное дерево поиска (BST)
|
||||||
|
Удаление узла зависит от количества его потомков:
|
||||||
|
?Нет детей (лист): узел просто удаляется, ссылка родителя обнуляется.
|
||||||
|
?Один ребёнок: удаляемый узел заменяется его единственным потомком — родитель «перепрыгивает» через удаляемый узел.
|
||||||
|
?Два ребёнка:
|
||||||
|
1.Находится преемник (самый левый (наименьший) узел в правом поддереве) или предшественник (самый правый (наибольший) узел в левом поддереве).
|
||||||
|
2.Значение преемника/предшественника копируется в удаляемый узел.
|
||||||
|
3.Преемник/предшественник рекурсивно удаляется — он гарантированно имеет не более одного ребёнка.
|
||||||
|
Сложность: O(h), где h — высота дерева. В сбалансированном дереве h=O(logn), в несбалансированном — до O(n).
|
||||||
|
|
||||||
|
Вывод
|
||||||
|
1. Частые вставки
|
||||||
|
Связный список — отличный выбор для частых вставок (особенно в середину), если не требуется быстрый доступ по индексу. Вставка в начало или конец выполняется за O(1), в середину — за O(n) (но без сдвига элементов, как в массиве).
|
||||||
|
Хеш таблица — хорошо подходит для вставок по ключу, обеспечивая в среднем O(1).
|
||||||
|
2. Частый поиск
|
||||||
|
Хеш таблица — лучший вариант для быстрого поиска по ключу. Среднее время — O(1), в худшем случае — O(n) (при сильных коллизиях).
|
||||||
|
Сбалансированное двоичное дерево поиска — предпочтительнее, если нужен поиск с гарантированной сложностью O(logn) даже в худшем случае.
|
||||||
|
3. Необходимость получать данные в отсортированном порядке
|
||||||
|
Массив / список — эффективен, если данные уже отсортированы или сортировка происходит редко, а последовательное чтение — часто. Доступ по индексу — O(1), но вставка и удаление в середину требуют O(n).
|
||||||
|
Отсортированный массив — удобен для поиска (бинарный поиск даёт (O(logn)), однако вставки и удаления обходятся в O(n).
|
||||||
|
Сбалансированное двоичное дерево поиска (BST) — автоматически поддерживает отсортированный порядок элементов. Все основные операции выполняются за O(logn). Идеальный вариант, когда данные часто изменяются и при этом требуется обход элементов в отсортированном порядке.
|
||||||
19
BobrovKN/zadanie/zad 1/results1.csv
Normal file
19
BobrovKN/zadanie/zad 1/results1.csv
Normal file
|
|
@ -0,0 +1,19 @@
|
||||||
|
Structure,Mode,Operation,Time_seconds
|
||||||
|
LinkedList,random,insert,7.967956480104476
|
||||||
|
LinkedList,random,find,0.05891917999833822
|
||||||
|
LinkedList,random,delete,0.03816298004239797
|
||||||
|
HashTable,random,insert,0.39825033992528913
|
||||||
|
HashTable,random,find,0.002917400002479553
|
||||||
|
HashTable,random,delete,0.0021501399576663973
|
||||||
|
BST,random,insert,0.02822491992264986
|
||||||
|
BST,random,find,0.00023473985493183136
|
||||||
|
BST,random,delete,0.00016456004232168198
|
||||||
|
LinkedList,sorted,insert,8.014810599852353
|
||||||
|
LinkedList,sorted,find,0.058480959851294756
|
||||||
|
LinkedList,sorted,delete,0.04817821998149156
|
||||||
|
HashTable,sorted,insert,0.3703480200842023
|
||||||
|
HashTable,sorted,find,0.002751259971410036
|
||||||
|
HashTable,sorted,delete,0.0018340200185775757
|
||||||
|
BST,sorted,insert,7.301413399912417
|
||||||
|
BST,sorted,find,0.06847236007452011
|
||||||
|
BST,sorted,delete,0.03443789994344115
|
||||||
|
Loading…
Reference in New Issue
Block a user