Переделан и реализован подсчёт времени для каждой СД

MusinAA/docs/Report 1.ipynb

@@ -10,7 +10,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 16,
    "id": "4689b73e",
    "metadata": {},
    "outputs": [],
@@ -38,16 +38,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
-   "id": "7d073d06",
+   "execution_count": 17,
+   "id": "a3b5c31b",
    "metadata": {},
    "outputs": [],
    "source": [
     "from util.randomNames import generate_test_data\n",
-    "records_shuffled = generate_test_data(N=10000)\n",
-    "records_sorted = generate_test_data(N=10000, _sorted=True)\n",
+    "from util.timeTester import test\n",
     "\n",
-    "from util.timeTester import insert_tester"
+    "records_shuffled = generate_test_data(N=10000)\n",
+    "records_sorted = generate_test_data(N=10000, _sorted=True)"
    ]
   },
   {
@@ -55,51 +55,63 @@
    "id": "c2f4989c",
    "metadata": {},
    "source": [
-    "# 2. Проведение замеров\n",
-    "### A. Время вставки"
+    "# 2. Проведение замеров"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "eba5888c",
+   "execution_count": 18,
+   "id": "df12d41d",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'Function': 'll_insert', 'shuffled': 4.4217493799999374, 'sorted': 5.294112365000046}\n",
-      "{'Function': 'ht_insert', 'shuffled': 0.338659952999933, 'sorted': 0.20052070199994887}\n",
-      "{'Function': 'bst_insert', 'shuffled': 0.01834327899996424, 'sorted': 0.18432242999983828}\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
+    "# Подготовим функции СД, которые будем тестировать\n",
     "from structures.LinkedList import *\n",
     "from structures.HashTable import *\n",
     "from structures.BinaryTree import *\n",
     "\n",
-    "print(insert_tester(ll_insert, records_shuffled, records_sorted))\n",
-    "print(insert_tester(ht_insert, records_shuffled, records_sorted))\n",
-    "print(insert_tester(bst_insert, records_shuffled, records_sorted))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "383c4b1b",
-   "metadata": {},
-   "source": [
-    "### Б. Поиск 100 случайных записей и 10 несуществующих"
+    "func_list = {\"Связанный список\" : (ll_insert,  ll_find,  ll_delete),\n",
+    "             \"Хэш-таблица\" : (ht_insert,  ht_find,  ht_delete),\n",
+    "             \"Бинарное дерево\" : (bst_insert, bst_find, bst_delete)}"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "d1acfa50",
+   "execution_count": 24,
+   "id": "cc8d0436",
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "# Проведём замеры\n",
+    "report = [[\"Структура\", \"Режим\", \"Вставка\", \"Поиск\", \"Удаление\"]]\n",
+    "records = {\"Cлучайный\" : records_shuffled, \"Отсортированный\" : records_sorted}\n",
+    "\n",
+    "TEST_ITERATIONS_NUM = 5\n",
+    "\n",
+    "for _ in range(TEST_ITERATIONS_NUM):\n",
+    "    for mode, data in records.items():\n",
+    "        for struct_name, fns in func_list.items():\n",
+    "            result = test(data, *fns)\n",
+    "            row = [struct_name, mode,\n",
+    "                result[\"insert_time\"],\n",
+    "                result[\"find_time\"],\n",
+    "                result[\"delete_time\"]]\n",
+    "            report.append(row)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "2eedf056",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Сохраним данные в csv\n",
+    "import csv\n",
+    "with open(\"data/results.csv\", \"w\", newline=\"\") as f:\n",
+    "    writer = csv.writer(f)\n",
+    "    writer.writerows(report)"
+   ]
   }
  ],
  "metadata": {
@@ -118,7 +130,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.2"
+   "version": "3.14.3"
   }
  },
  "nbformat": 4,

MusinAA/docs/data/results.csv

@@ -0,0 +1,31 @@
+Структура,Режим,Вставка,Поиск,Удаление
+Связанный список,Cлучайный,6.184219556999778,0.01564759699977003,0.020917029999509396
+Хэш-таблица,Cлучайный,0.20728507099920535,0.0011867590001202188,0.0012845039991589147
+Бинарное дерево,Cлучайный,0.01599855899985414,0.00017333699997834628,0.0001880449999589473
+Связанный список,Отсортированный,6.1492630290003945,0.08403158500004793,0.11902903299960599
+Хэш-таблица,Отсортированный,0.1831843130003108,0.003145785999549844,0.0030832479997116025
+Бинарное дерево,Отсортированный,0.17353334099971107,0.0018611919995237258,0.001973905000340892
+Связанный список,Cлучайный,5.064191275000667,0.015435045000231185,0.021122407000802923
+Хэш-таблица,Cлучайный,0.21584205599992856,0.001062764999915089,0.0010387600004833075
+Бинарное дерево,Cлучайный,0.01586526800019783,0.0001650120002523181,0.0002011500000662636
+Связанный список,Отсортированный,5.008700298999429,0.08874143100001675,0.11785725200024899
+Хэш-таблица,Отсортированный,0.16122512399942934,0.0027618209996944643,0.0031808120002096985
+Бинарное дерево,Отсортированный,0.16625836200000776,0.0017326589995718678,0.0018288709998159902
+Связанный список,Cлучайный,4.973175217000062,0.016034526000112237,0.029878299000301922
+Хэш-таблица,Cлучайный,0.19947776500066539,0.0008432810000158497,0.0009618849999242229
+Бинарное дерево,Cлучайный,0.015627648000190675,0.00015909000012470642,0.00018263399942952674
+Связанный список,Отсортированный,4.7649637760005135,0.07843009399948642,0.11216894700010016
+Хэш-таблица,Отсортированный,0.16914973799975996,0.0028197709998494247,0.003400436000447371
+Бинарное дерево,Отсортированный,0.16913629200007563,0.00174245800008066,0.00184838800032594
+Связанный список,Cлучайный,5.070599788999971,0.023625830999662867,0.024334026999895286
+Хэш-таблица,Cлучайный,0.2566551750005601,0.001680571000179043,0.0019877810000252794
+Бинарное дерево,Cлучайный,0.02019279199976154,0.00019776400040427689,0.0002360259995839442
+Связанный список,Отсортированный,5.0148616579999725,0.08842415099934442,0.13560766399950808
+Хэш-таблица,Отсортированный,0.18670927000039228,0.0038891280000825645,0.0034846049993575434
+Бинарное дерево,Отсортированный,0.1774570309999035,0.0019291399994472158,0.0021798640000270098
+Связанный список,Cлучайный,5.373787051000363,0.021812238000165962,0.025861819999590807
+Хэш-таблица,Cлучайный,0.19457704500018735,0.00110557600055472,0.0010436189995743916
+Бинарное дерево,Cлучайный,0.015349283000432479,0.00016242600031546317,0.00017538100019010017
+Связанный список,Отсортированный,5.167020247999972,0.08513789999960863,0.12899004599967157
+Хэш-таблица,Отсортированный,0.18223923400000785,0.0032350740002584644,0.0037601450003421633
+Бинарное дерево,Отсортированный,0.1719607389995872,0.0017423979998056893,0.0018891839999923832

MusinAA/task1/structures/BinaryTree.py

@@ -37,7 +37,7 @@ def bst_find(root: dict|None, name: str) -> str|None:
     if node != None:
         return node['phone']
 
-def find_node_to_delete(root: dict, name: str) -> dict|None:
+def find_node_to_delete(root: dict|None, name: str) -> dict|None:
     """Поиск в ширину."""
     while root != None:
         if root['name'] == name:

MusinAA/task1/structures/HashTable.py

@@ -20,7 +20,7 @@ def hash_fun(name: str, size: int) -> int:
         n -= 1
     return int(hashSum) % size
 
-def ht_insert(buckets: list, name: str, phone: str, blen:int = 50) -> list:
+def ht_insert(buckets: list|None, name: str, phone: str, blen:int = 50) -> list:
     """Возвращает новый массив бакетов
     Вычисляет индекс, вызывает ll_insert для соответствующего бакета.
     Функция не меняет размер массива бакетов автоматически!"""
@@ -43,8 +43,8 @@ def ht_delete(buckets: list, name: str) -> list:
     buckets[index] = ll_delete(buckets[index], name)
     return buckets
 
-def ht_find(buckets: list, name: str) -> str:
-    if buckets == []:
+def ht_find(buckets: list|None, name: str) -> str|None:
+    if buckets == [] or buckets == None:
         raise ValueError("Длинна buckets должна быть больше 0")
 
     size = len(buckets)

MusinAA/task1/structures/LinkedList.py

@@ -32,7 +32,7 @@ def ll_find(head : dict|None, name: str) -> str|None:
         currentNode = currentNode['next']
     return None
 
-def ll_delete(head : dict|None, name: str) -> dict:
+def ll_delete(head : dict|None, name: str) -> dict|None:
     """Удаляет узел, возвращает новую голову."""
     if head == None:
         return None

MusinAA/task1/util/randomNames.py

@@ -31,6 +31,14 @@ names_pool = (
     "Добрыня"
 )
 
+_non_existent_names = [
+    "Ноль", "Целковый", "Полушка", "Четвертушка", "Осьмушка",
+    "Пудовичок", "Медячок", "Серебрячок", "Золотничок", "Девятичок"
+]
+assert set(names_pool).isdisjoint(set(_non_existent_names)), \
+"В списке несуществующих имён существуют существующие имена сущностей"
+names_pool_to_find = random.choices(names_pool, k=100) + _non_existent_names
+
 def generate_phone(phone_len=11) -> str:
     # 88005553535
     return str(random.randint(10**phone_len, 10**(phone_len+1)-1))

MusinAA/task1/util/timeTester.py

@@ -1,24 +1,36 @@
 import time
 from typing import Callable, Any
+from task1.util.randomNames import names_pool_to_find
 
-def _concrete_insert_tester(func: Callable[[Any, str, str], Any], records: list) -> float:
-    """Исследует время работы функции вставки"""
-    aboba = None
-
+def test(records: list,
+         insert_func: Callable[[Any, str, str], Any],
+         find_func: Callable[[Any, str], Any],
+         delete_func: Callable[[Any, str], Any]) -> dict:
+    data = None
+    
+    # Вставка всех записей
     start = time.perf_counter()
     for item in records:
-        aboba = func(aboba, name=item[0], phone=item[1])
+        data = insert_func(data, item[0], item[1])
     end = time.perf_counter()
+    insert_time = end - start
 
-    elapsed = end - start
-    return elapsed
+    # Поиск 110 случайных записей
+    start = time.perf_counter()
+    for name in names_pool_to_find:
+        find_func(data, name)
+    end = time.perf_counter()
+    find_time = end - start
 
-def insert_tester(func_to_test: Callable[[Any, str, str], Any], records_shuffled, records_sorted) -> dict:
-    """Возвращает словарь с временем сортировки в обоих режимах"""
-    shuffled = _concrete_insert_tester(func_to_test, records_shuffled)
-    sorted = _concrete_insert_tester(func_to_test, records_sorted)
-
-    return {"Function": func_to_test.__name__,
-            "shuffled": shuffled,
-            "sorted": sorted
-            }
+    # Удаление 50 случайных записей
+    start = time.perf_counter()
+    for name in names_pool_to_find:
+        data = delete_func(data, name)
+    end = time.perf_counter()
+    delete_time = end - start
+    
+    return {
+        "insert_time" : insert_time ,
+        "find_time" : find_time ,
+        "delete_time":  delete_time
+    }