From bb1eebe572089080ad076cc2e4615ee3aaeb8fcd Mon Sep 17 00:00:00 2001 From: unknown Date: Sat, 5 Sep 2026 13:21:50 +0300 Subject: [PATCH] [1] zad 1 --- BobrovKN/zadanie/zad 1/1.py | 292 ++++++++++++++++++++++++++++ BobrovKN/zadanie/zad 1/otchet1.txt | 122 ++++++++++++ BobrovKN/zadanie/zad 1/results1.csv | 19 ++ 3 files changed, 433 insertions(+) create mode 100644 BobrovKN/zadanie/zad 1/1.py create mode 100644 BobrovKN/zadanie/zad 1/otchet1.txt create mode 100644 BobrovKN/zadanie/zad 1/results1.csv diff --git a/BobrovKN/zadanie/zad 1/1.py b/BobrovKN/zadanie/zad 1/1.py new file mode 100644 index 0000000..24c59b7 --- /dev/null +++ b/BobrovKN/zadanie/zad 1/1.py @@ -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() \ No newline at end of file diff --git a/BobrovKN/zadanie/zad 1/otchet1.txt b/BobrovKN/zadanie/zad 1/otchet1.txt new file mode 100644 index 0000000..51c977a --- /dev/null +++ b/BobrovKN/zadanie/zad 1/otchet1.txt @@ -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). Идеальный вариант, когда данные часто изменяются и при этом требуется обход элементов в отсортированном порядке. diff --git a/BobrovKN/zadanie/zad 1/results1.csv b/BobrovKN/zadanie/zad 1/results1.csv new file mode 100644 index 0000000..0c54514 --- /dev/null +++ b/BobrovKN/zadanie/zad 1/results1.csv @@ -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