lukovnikovde/docs/data/DataStructure.py

@@ -0,0 +1,507 @@
+import random as rnd
+import time
+import csv
+import matplotlib.pyplot as plt
+#############################################################################################
+
+def sort_list(name_list):
+    l = len(name_list)
+    for i in range(l - 1):
+        for j in range(l - i - 1):
+            if name_list[j][0] > name_list[j + 1][0]:
+                name_list[j], name_list[j + 1] = name_list[j + 1], name_list[j]
+    return name_list
+ 
+def hash_key(name):
+    h_key = sum(ord(ch) for ch in name)
+    return h_key
+
+def create_name_phone(i):
+    name = f"User_{i:03d}"
+    phone = f"{rnd.randint(100, 999)}-{rnd.randint(100, 999)}"
+    return (name, phone)
+
+def file_insert(results):
+    with open("results.csv", "w", encoding = "utf-8-sig", newline = "") as file:
+        writer = csv.writer(file)
+        writer.writerows(results)
+        
+def drow(time, color_fun, j, text, axes):
+
+    operation = [0, 1, 2, 3]
+    x = [j + operation[i] for i in range(4)]
+    y = []
+    for key in time:
+        y.append(time[key] * 1000)
+    for i in range(4):
+        axes[i].bar(x[i], y[i], width = 0.12,  color = color_fun, label = text)
+        axes[i].set_ylabel("Время, мс") 
+        axes[i].set_xticks([])
+    #plt.bar(x, y, width = 0.12, color = color_fun, label = text)
+    
+        
+        
+###########################################################################################################################
+
+def ll_insert(head, name, phone):
+    next_node = {'name': name, 'phone': phone, 'next': None}
+    if head is None: return next_node 
+
+    running = head
+    while running is not None:
+        if running['name'] == name:
+            running['phone'] = phone
+            return head
+        running = running['next']
+
+    running = head
+    while running['next'] is not None: running = running['next']
+    running['next'] = next_node
+    return head
+
+def ll_find(head, name):
+    running = head
+
+    while True:
+        if running['name'] == name:
+            return running['phone']
+        running = running['next']
+        if running is None: break
+
+    return None
+
+
+def ll_delete(head, name):
+    running = head
+    
+    if running['name'] == name: 
+        return head['next']
+
+    while running['next']['name'] != name: 
+        running = running['next']
+        if  running['next']['next'] is None:
+            if running['next']['name'] != name:
+                return head
+    if running['next']['next'] is None: 
+        running['next'] = None
+    else: running['next'] = running['next']['next']
+
+    return head
+    
+
+def ll_list_all(head):
+    name_list = []
+    running = head
+    while running is not None:
+        name_list.append((running['name'], running['phone']))     
+        running = running['next']
+    return name_list
+
+################################################################################################################################
+
+
+def LinkedList(head, phone_book):
+
+    start_insert = time.perf_counter()
+    for i in range(len(phone_book)):
+
+        head = ll_insert(head, phone_book[i][0], phone_book[i][1])
+    #print(head)
+    end_insert = time.perf_counter()
+    time_insert = end_insert - start_insert
+
+    start_find = time.perf_counter()
+    for _ in range(100):
+        name = create_name_phone(rnd.randint(0, 999))[0]
+        phone = ll_find(head, name)
+        #print(name, ":", phone)
+    end_find = time.perf_counter()
+    time_find = end_find - start_find
+    
+    
+    start_delete = time.perf_counter()
+    for i in range(110):
+        if i <= 99: name = f"User_{rnd.randint(0,999):03d}"
+        else: name = f"None_{i:03d}"
+        head = ll_delete(head, name)
+    end_delete = time.perf_counter()
+    time_delete = end_delete - start_delete
+        
+    
+    start_list = time.perf_counter()    
+    name_list = sort_list(ll_list_all(head))
+    #print(*name_list)
+    end_list = time.perf_counter()
+    time_list = end_list - start_list
+    
+    return (time_insert, time_find, time_delete, time_list)
+
+#########################################################################################################
+
+def ht_insert(buckest, name, phone):
+    index = hash_key(name) % len(buckest)
+    for i, (Name, Phone) in enumerate(buckest[index]):
+        if Name == name:
+            buckest[index][i] = (name, phone)
+            return buckest
+    buckest[index].append((name, phone))
+    return buckest
+
+def ht_find(buckest, name):
+    index = hash_key(name) % len(buckest)
+    for (Name, Phone) in buckest[index]:
+        if Name == name:
+            return Phone
+    return None
+
+def ht_list_all(buckest):
+    
+    name_list = []
+
+    for index in range(len(buckest)):
+        for i, (name, phone) in enumerate(buckest[index]):
+            name_list.append((name, phone))
+
+    name_list = sort_list(name_list)
+
+    return name_list
+
+
+def ht_delete(buckest, name):
+    index = hash_key(name) % len(buckest)
+    for i, (Name, Phone) in enumerate(buckest[index]):
+        if Name == name:
+            del buckest[index][i]
+    return buckest
+
+
+####################################################################################################
+
+def HashTable(buckest, phone_book):
+
+
+    start_insert = time.perf_counter()
+    for i in range(len(phone_book)):
+
+        buckest = ht_insert(buckest, phone_book[i][0], phone_book[i][1])
+    #print(buckest)
+    end_insert = time.perf_counter()
+    time_insert = end_insert - start_insert
+
+
+    start_find = time.perf_counter()
+    for _ in range(100):
+        name = create_name_phone(rnd.randint(0, 999))[0]
+        phone = ht_find(buckest, name)
+        #print(name, ":", phone)
+    end_find = time.perf_counter()
+    time_find = end_find - start_find
+    
+    
+    start_delete = time.perf_counter()
+    for i in range(110):
+        if i <= 99: name = f"User_{rnd.randint(0,999):03d}"
+        else: name = f"None_{i:03d}"
+        buckest = ht_delete(buckest, name)
+    end_delete = time.perf_counter()
+    time_delete = end_delete - start_delete
+        
+    
+    start_list = time.perf_counter()    
+    name_list = sort_list(ht_list_all(buckest))
+    #print(*name_list)
+    end_list = time.perf_counter()
+    time_list = end_list - start_list
+    
+    return (time_insert, time_find, time_delete, time_list)
+
+#################################################################################################
+
+def bst_insert(root, name, phone):
+    
+    running = root
+
+    if running is None:
+        root = {'name': name, 'phone': phone, 'left': None, 'right': None}
+        return root
+    while True:
+        node = hash_key(running['name'])
+        sheet = hash_key(name)
+        if node < sheet:
+            if running['right'] is None:
+                running['right'] = {'name': name, 'phone': phone, 'left': None, 'right': None}
+                return root
+            running = running['right']
+        elif node > sheet:
+            if running['left'] is None:
+                running['left'] = {'name': name, 'phone': phone, 'left': None, 'right': None}
+                return root
+            running = running['left']
+        else:
+             running['phone'] = phone
+             return root
+
+def bst_find(root, name):
+
+    running = root
+
+    while running is not None:
+        node = hash_key(running['name'])
+        sheet = hash_key(name)
+        if name == running['name']:
+            return running['phone']
+        elif node < sheet:
+            running = running['right']
+        else:
+            running = running['left']
+
+    return None
+
+def bst_list_all(root, name_list = []):
+    if root is None:
+        return
+    name_list.append((root['name'], root['phone']))
+    bst_list_all(root['left'], name_list)
+    bst_list_all(root['right'], name_list)
+    name_list = sort_list(name_list)
+    return name_list
+    
+def bst_delete(root, name):
+    
+    if root is None:
+        return None
+    if hash_key(name) < hash_key(root['name']):
+        root['left'] = bst_delete(root['left'], name)
+    elif hash_key(name) > hash_key(root['name']):
+        root['right'] = bst_delete(root['right'], name)
+    else:
+        
+        if root['left'] is None and root['right'] is None:
+            return None
+    
+        if root['left'] is None:
+            return root['right']
+        if root['right'] is None:
+            return root['left']
+        
+        min_node = root['right']
+        while min_node['left'] is not None:
+            min_node = min_node['left']
+            
+        root['name'] = min_node['name']
+        root['phone'] = min_node['phone']
+
+        root['right'] = bst_delete(root['right'], min_node['name'])            
+    
+    return root
+    
+#################################################################################################
+
+def BinarySearchTree(root, phone_book):
+
+    start_insert = time.perf_counter()
+    for i in range(len(phone_book)):
+
+        root = bst_insert(root, phone_book[i][0], phone_book[i][1])
+    #print(buckest)
+    end_insert = time.perf_counter()
+    time_insert = end_insert - start_insert
+
+
+    start_find = time.perf_counter()
+    for _ in range(100):
+        name = create_name_phone(rnd.randint(0, 999))[0]
+        phone = bst_find(root, name)
+        #print(name, ":", phone)
+    end_find = time.perf_counter()
+    time_find = end_find - start_find
+    
+    
+    start_delete = time.perf_counter()
+    for i in range(110):
+        if i <= 99: name = f"User_{rnd.randint(0,999):03d}"
+        else: name = f"None_{i:03d}"
+        root = bst_delete(root, name)
+    end_delete = time.perf_counter()
+    time_delete = end_delete - start_delete
+        
+    
+    start_list = time.perf_counter()    
+    name_list = sort_list(bst_list_all(root))
+    #print(*name_list)
+    end_list = time.perf_counter()
+    time_list = end_list - start_list
+    
+    return (time_insert, time_find, time_delete, time_list)
+
+################################################################################################
+def main():
+    
+    phone_book = []
+    for i in range(1000):
+        phone_book.append(create_name_phone(i))
+    for _ in range(9000):
+        phone_book.append(create_name_phone(rnd.randint(0, 999)))
+    
+    phone_book_not_sorted = phone_book.copy()
+    rnd.shuffle(phone_book_not_sorted)
+    
+    phone_book_sorted = phone_book.copy()
+    phone_book_sorted = sort_list(phone_book_sorted)
+    replay = 10
+    
+    
+    Time_ll_not_sorted = []
+    Time_ll_sorted =  []
+    
+    Time_average_ll_not_sorted = {'insert': 0, 'find': 0, 'delete': 0, 'list': 0}
+    Time_average_ll_sorted =  {'insert': 0, 'find': 0, 'delete': 0, 'list': 0}
+    
+    print("============================================ TESTING LINKEDLIST =====================================\n")
+    print('Not sorted: ')
+    for _ in range(replay):
+        time_ll_not_sorted = LinkedList(None, phone_book_not_sorted)
+        Time_ll_not_sorted.append({'insert': time_ll_not_sorted[0], 'find': time_ll_not_sorted[1], 'delete': time_ll_not_sorted[2], 'list': time_ll_not_sorted[3]})
+        for i, key in enumerate(Time_average_ll_not_sorted):
+            Time_average_ll_not_sorted[key] += time_ll_not_sorted[i]/replay
+    for i in range(replay):
+        print(Time_ll_not_sorted[i])
+    print("Average:", Time_average_ll_not_sorted, "\n\n")
+        
+    print('Sorted:')    
+    for _ in range(replay):
+        time_ll_sorted = LinkedList(None, phone_book_sorted)
+        Time_ll_sorted.append({'insert': time_ll_sorted[0], 'find': time_ll_sorted[1], 'delete': time_ll_sorted[2], 'list': time_ll_sorted[3]})
+        for i, key in enumerate(Time_average_ll_sorted):
+            Time_average_ll_sorted[key] += time_ll_sorted[i]/replay
+    for i in range(replay):
+        print(Time_ll_not_sorted[i])    
+    print("Average:", Time_average_ll_sorted, "\n\n")
+        
+        
+        
+    Time_ht_not_sorted = []
+    Time_ht_sorted = []
+
+    Time_average_ht_not_sorted = {'insert': 0, 'find': 0, 'delete': 0, 'list': 0}
+    Time_average_ht_sorted =  {'insert': 0, 'find': 0, 'delete': 0, 'list': 0} 
+    
+    print("============================================ TESTING HASHTABLE =====================================\n")
+    print('Not sorted: ')
+    for _ in range(replay):
+        time_ht_not_sorted = HashTable([[] for _ in range(100)], phone_book_not_sorted)
+        Time_ht_not_sorted.append({'insert': time_ht_not_sorted[0], 'find': time_ht_not_sorted[1], 'delete': time_ht_not_sorted[2], 'list': time_ht_not_sorted[3]})
+        for i, key in enumerate(Time_average_ht_not_sorted):
+            Time_average_ht_not_sorted[key] += time_ht_not_sorted[i]/replay
+    for i in range(replay):
+        print(Time_ht_not_sorted[i])
+    print(f"Average: {Time_average_ht_not_sorted}\n\n")
+    
+    print('Sorted: ')
+    for _ in range(replay):
+        time_ht_sorted = HashTable([[] for _ in range(100)], phone_book_sorted)
+        Time_ht_sorted.append({'insert': time_ht_sorted[0], 'find': time_ht_sorted[1], 'delete': time_ht_sorted[2], 'list': time_ht_sorted[3]})
+        for i, key in enumerate(Time_average_ht_sorted):
+            Time_average_ht_sorted[key] += time_ht_sorted[i]/replay
+    for i in range(replay):
+        print(Time_ht_sorted[i])
+    print(f"Average: {Time_average_ht_sorted}\n\n")    
+       
+    
+    
+    Time_bst_not_sorted = []
+    Time_bst_sorted = []
+
+    Time_average_bst_not_sorted = {'insert': 0, 'find': 0, 'delete': 0, 'list': 0}
+    Time_average_bst_sorted =  {'insert': 0, 'find': 0, 'delete': 0, 'list': 0}  
+    
+    print("============================================ TESTING BINARYSEARCHTREE =====================================\n")
+    print('Not sorted: ')
+    for _ in range(replay):
+        time_bst_not_sorted = BinarySearchTree(None, phone_book_not_sorted)
+        Time_bst_not_sorted.append({'insert': time_bst_not_sorted[0], 'find': time_bst_not_sorted[1], 'delete': time_bst_not_sorted[2], 'list': time_bst_not_sorted[3]})
+        for i, key in enumerate(Time_average_bst_not_sorted):
+            Time_average_bst_not_sorted[key] += time_bst_not_sorted[i]/replay
+    for i in range(replay):
+        print(Time_bst_not_sorted[i])
+    print(f"Average: {Time_average_bst_not_sorted}\n\n")
+    
+    print('Sorted: ')
+    for _ in range(replay):
+        time_bst_sorted = BinarySearchTree(None, phone_book_sorted)
+        Time_bst_sorted.append({'insert': time_bst_sorted[0], 'find': time_bst_sorted[1], 'delete': time_bst_sorted[2], 'list': time_bst_sorted[3]})
+        for i, key in enumerate(Time_average_bst_sorted):
+            Time_average_bst_sorted[key] += time_bst_sorted[i]/replay
+    for i in range(replay):
+        print(Time_bst_sorted[i])
+    print(f"Average: {Time_average_bst_sorted}\n\n")    
+    print("=============================================== END TESTING ================================================")
+    
+    results = [["Структура", "Режим", "Операция", "Время(мс)"]]
+    for i in range(replay):
+        results.append(["LinkedList", "Случайный", "вставка", Time_ll_not_sorted[i]["insert"]])
+        results.append(["LinkedList", "Случайный", "поиск", Time_ll_not_sorted[i]["find"]])
+        results.append(["LinkedList", "Случайный", "удаление", Time_ll_not_sorted[i]["delete"]])
+        results.append(["LinkedList", "Случайный", "формирование списка", Time_ll_not_sorted[i]["list"]])
+        
+        results.append(["LinkedList", "Упорядоченный", "вставка", Time_ll_sorted[i]["insert"]])
+        results.append(["LinkedList", "Упорядоченный", "поиск", Time_ll_sorted[i]["find"]])
+        results.append(["LinkedList", "Упорядоченный", "удаление", Time_ll_sorted[i]["delete"]])
+        results.append(["LinkedList", "Упорядоченный", "формирование списка", Time_ll_sorted[i]["list"]])
+        
+    for i in range(replay):
+        results.append(["HashTable", "Случайный", "вставка", Time_ht_not_sorted[i]["insert"]])
+        results.append(["HashTable", "Случайный", "поиск", Time_ht_not_sorted[i]["find"]])
+        results.append(["HashTable", "Случайный", "удаление", Time_ht_not_sorted[i]["delete"]])
+        results.append(["HashTable", "Случайный", "формирование списка", Time_ht_not_sorted[i]["list"]])
+        
+        results.append(["HashTable", "Упорядоченный", "вставка", Time_ht_sorted[i]["insert"]])
+        results.append(["HashTable", "Упорядоченный", "поиск", Time_ht_sorted[i]["find"]])
+        results.append(["HashTable", "Упорядоченный", "удаление", Time_ht_sorted[i]["delete"]])
+        results.append(["HashTable", "Упорядоченный", "формирование списка", Time_ht_sorted[i]["list"]])
+
+    for i in range(replay):
+        results.append(["BinarySearchTree", "Случайный", "вставка", Time_bst_not_sorted[i]["insert"]])
+        results.append(["BinarySearchTree", "Случайный", "поиск", Time_bst_not_sorted[i]["find"]])
+        results.append(["BinarySearchTree", "Случайный", "удаление", Time_bst_not_sorted[i]["delete"]])
+        results.append(["BinarySearchTree", "Случайный", "формирование списка", Time_bst_not_sorted[i]["list"]])
+        
+        results.append(["BinarySearchTree", "Упорядоченный", "вставка", Time_bst_sorted[i]["insert"]])
+        results.append(["BinarySearchTree", "Упорядоченный", "поиск", Time_bst_sorted[i]["find"]])
+        results.append(["BinarySearchTree", "Упорядоченный", "удаление", Time_bst_sorted[i]["delete"]])
+        results.append(["BinarySearchTree", "Упорядоченный", "формирование списка", Time_bst_sorted[i]["list"]])
+        
+    for i in range(1, len(results) - 1):
+        results[i][3] *= 1000    
+    file_insert(results)
+    
+    fig, axes = plt.subplots(1, 4, figsize = (16, 5))
+    manager = plt.get_current_fig_manager()
+    manager.full_screen_toggle()
+
+
+    drow(Time_average_ll_not_sorted, "#0800FF", -0.3, "LinkedList (not sorted)", axes) 
+    drow(Time_average_ll_sorted, "#00C8FF", -0.18, "LinkedList (sorted)", axes)
+    drow(Time_average_ht_not_sorted, "#0E7A13", -0.06, "HashTable (not sorted)", axes)
+    drow(Time_average_ht_sorted, "#4DFF00", 0.06, "HashTable (sorted)", axes)
+    drow(Time_average_bst_not_sorted, "#968C1A", 0.18, "BST (not sorted)", axes)
+    drow(Time_average_bst_sorted, "#FBFF00", 0.30, "BST (sorted)", axes)
+    
+    operation = ['insert', 'find', 'delete', 'create list']
+    
+    for i in range(4):
+        axes[i].set_title(operation[i])
+    plt.legend(bbox_to_anchor = (1.05, 1), loc = "upper left")
+
+
+
+    plt.subplots_adjust(bottom = 0.025, top = 0.95, left = 0.025, right = 0.875)
+    plt.savefig("time_schedule.png")
+    plt.show()
+
+if __name__ == "__main__":
+    main()
+
+
+
+

lukovnikovde/docs/data/resalts.csv

@@ -0,0 +1,241 @@
+Структура,Режим,Операция,Время(мс)
+LinkedList,Случайный,вставка,159.38230000028852
+LinkedList,Случайный,поиск,1.608700000360841
+LinkedList,Случайный,удаление,3.333099999508704
+LinkedList,Случайный,формирование списка,31.43850000014936
+LinkedList,Упорядоченный,вставка,176.2546999998449
+LinkedList,Упорядоченный,поиск,1.7821999990701443
+LinkedList,Упорядоченный,удаление,3.542399999787449
+LinkedList,Упорядоченный,формирование списка,21.29400000012538
+LinkedList,Случайный,вставка,160.5120000003808
+LinkedList,Случайный,поиск,1.5978000010363758
+LinkedList,Случайный,удаление,3.5874000004696427
+LinkedList,Случайный,формирование списка,31.3373999997566
+LinkedList,Упорядоченный,вставка,169.6819000007963
+LinkedList,Упорядоченный,поиск,1.6672000001562992
+LinkedList,Упорядоченный,удаление,3.06300000011106
+LinkedList,Упорядоченный,формирование списка,21.382199998697615
+LinkedList,Случайный,вставка,162.45290000006207
+LinkedList,Случайный,поиск,1.6584000004513655
+LinkedList,Случайный,удаление,3.0743000006623333
+LinkedList,Случайный,формирование списка,31.488399999943795
+LinkedList,Упорядоченный,вставка,169.72099999838974
+LinkedList,Упорядоченный,поиск,1.7922000006365124
+LinkedList,Упорядоченный,удаление,3.3667999996396247
+LinkedList,Упорядоченный,формирование списка,21.698699998523807
+LinkedList,Случайный,вставка,163.0209000013565
+LinkedList,Случайный,поиск,1.6841999986354494
+LinkedList,Случайный,удаление,3.2122999982675537
+LinkedList,Случайный,формирование списка,31.478799999604234
+LinkedList,Упорядоченный,вставка,172.49460000130057
+LinkedList,Упорядоченный,поиск,1.756999999997788
+LinkedList,Упорядоченный,удаление,3.196600000592298
+LinkedList,Упорядоченный,формирование списка,21.166299999094917
+LinkedList,Случайный,вставка,163.07450000022072
+LinkedList,Случайный,поиск,1.8555999995442107
+LinkedList,Случайный,удаление,3.40919999871403
+LinkedList,Случайный,формирование списка,31.833799999731127
+LinkedList,Упорядоченный,вставка,170.02059999867924
+LinkedList,Упорядоченный,поиск,1.552300000184914
+LinkedList,Упорядоченный,удаление,3.814900001088972
+LinkedList,Упорядоченный,формирование списка,21.307799999704002
+LinkedList,Случайный,вставка,168.1974999992235
+LinkedList,Случайный,поиск,2.0230999998602783
+LinkedList,Случайный,удаление,3.5730999989027623
+LinkedList,Случайный,формирование списка,32.19399999943562
+LinkedList,Упорядоченный,вставка,169.28159999952186
+LinkedList,Упорядоченный,поиск,1.713900001050206
+LinkedList,Упорядоченный,удаление,3.4302999993087724
+LinkedList,Упорядоченный,формирование списка,21.549899998717592
+LinkedList,Случайный,вставка,169.27700000087498
+LinkedList,Случайный,поиск,1.7975999999180203
+LinkedList,Случайный,удаление,3.151300001263735
+LinkedList,Случайный,формирование списка,31.799799999134848
+LinkedList,Упорядоченный,вставка,171.0044999999809
+LinkedList,Упорядоченный,поиск,1.743999999234802
+LinkedList,Упорядоченный,удаление,3.8127000007079914
+LinkedList,Упорядоченный,формирование списка,21.345600000131526
+LinkedList,Случайный,вставка,173.35669999920356
+LinkedList,Случайный,поиск,1.8798999990394805
+LinkedList,Случайный,удаление,3.4422999997332226
+LinkedList,Случайный,формирование списка,32.4691999994684
+LinkedList,Упорядоченный,вставка,169.52339999988908
+LinkedList,Упорядоченный,поиск,1.728800001728814
+LinkedList,Упорядоченный,удаление,3.3399000003555557
+LinkedList,Упорядоченный,формирование списка,21.254400000543683
+LinkedList,Случайный,вставка,169.77609999958077
+LinkedList,Случайный,поиск,1.6739000002417015
+LinkedList,Случайный,удаление,3.73560000116413
+LinkedList,Случайный,формирование списка,31.469499999730033
+LinkedList,Упорядоченный,вставка,171.0146999994322
+LinkedList,Упорядоченный,поиск,1.6797999996924773
+LinkedList,Упорядоченный,удаление,3.45019999986107
+LinkedList,Упорядоченный,формирование списка,21.524600000702776
+LinkedList,Случайный,вставка,167.06580000027316
+LinkedList,Случайный,поиск,1.8982999990839744
+LinkedList,Случайный,удаление,3.6678999986179406
+LinkedList,Случайный,формирование списка,32.446200000777026
+LinkedList,Упорядоченный,вставка,171.11090000071272
+LinkedList,Упорядоченный,поиск,1.7826000002969522
+LinkedList,Упорядоченный,удаление,3.3842000011645723
+LinkedList,Упорядоченный,формирование списка,21.2576000012632
+HashTable,Случайный,вставка,17.278299999816227
+HashTable,Случайный,поиск,0.3028999999514781
+HashTable,Случайный,удаление,0.3226000007998664
+HashTable,Случайный,формирование списка,47.606800000721705
+HashTable,Упорядоченный,вставка,16.69159999983094
+HashTable,Упорядоченный,поиск,0.278499999694759
+HashTable,Упорядоченный,удаление,0.31350000062957406
+HashTable,Упорядоченный,формирование списка,47.49850000007427
+HashTable,Случайный,вставка,18.00539999931061
+HashTable,Случайный,поиск,0.28170000041427556
+HashTable,Случайный,удаление,0.3051999992749188
+HashTable,Случайный,формирование списка,48.14599999917846
+HashTable,Упорядоченный,вставка,18.065500000375323
+HashTable,Упорядоченный,поиск,0.28329999986453913
+HashTable,Упорядоченный,удаление,0.32250000003841706
+HashTable,Упорядоченный,формирование списка,47.55000000113796
+HashTable,Случайный,вставка,16.97520000016084
+HashTable,Случайный,поиск,0.2812000002450077
+HashTable,Случайный,удаление,0.3178000006300863
+HashTable,Случайный,формирование списка,47.868200001175865
+HashTable,Упорядоченный,вставка,18.372099999396596
+HashTable,Упорядоченный,поиск,0.3102999999100575
+HashTable,Упорядоченный,удаление,0.3297000002930872
+HashTable,Упорядоченный,формирование списка,48.02730000119482
+HashTable,Случайный,вставка,16.71149999856425
+HashTable,Случайный,поиск,0.27319999935571104
+HashTable,Случайный,удаление,0.3262999998696614
+HashTable,Случайный,формирование списка,47.846100000242586
+HashTable,Упорядоченный,вставка,18.567699999039178
+HashTable,Упорядоченный,поиск,0.2848999993148027
+HashTable,Упорядоченный,удаление,0.3262999998696614
+HashTable,Упорядоченный,формирование списка,48.06850000022678
+HashTable,Случайный,вставка,16.770899999755784
+HashTable,Случайный,поиск,0.26760000037029386
+HashTable,Случайный,удаление,0.3209000005881535
+HashTable,Случайный,формирование списка,48.08539999976347
+HashTable,Упорядоченный,вставка,17.05279999987397
+HashTable,Упорядоченный,поиск,0.2679999997781124
+HashTable,Упорядоченный,удаление,0.31599999965692405
+HashTable,Упорядоченный,формирование списка,48.27990000012505
+HashTable,Случайный,вставка,17.21460000044317
+HashTable,Случайный,поиск,0.27520000003278255
+HashTable,Случайный,удаление,0.3281999997852836
+HashTable,Случайный,формирование списка,47.93720000088797
+HashTable,Упорядоченный,вставка,17.084900000554626
+HashTable,Упорядоченный,поиск,0.2795999989757547
+HashTable,Упорядоченный,удаление,0.3280000000813743
+HashTable,Упорядоченный,формирование списка,47.76760000095237
+HashTable,Случайный,вставка,16.898900001251604
+HashTable,Случайный,поиск,0.2705999995669117
+HashTable,Случайный,удаление,0.3180999992764555
+HashTable,Случайный,формирование списка,48.1019999988348
+HashTable,Упорядоченный,вставка,17.074800000045798
+HashTable,Упорядоченный,поиск,0.27850000151374843
+HashTable,Упорядоченный,удаление,0.3259999994043028
+HashTable,Упорядоченный,формирование списка,48.0186999993748
+HashTable,Случайный,вставка,17.024499999024556
+HashTable,Случайный,поиск,0.2716999988479074
+HashTable,Случайный,удаление,0.3228999994462356
+HashTable,Случайный,формирование списка,48.31470000135596
+HashTable,Упорядоченный,вставка,17.382100000759237
+HashTable,Упорядоченный,поиск,0.2786999993986683
+HashTable,Упорядоченный,удаление,0.3171999996993691
+HashTable,Упорядоченный,формирование списка,47.687000000223634
+HashTable,Случайный,вставка,17.80959999996412
+HashTable,Случайный,поиск,0.28049999855284113
+HashTable,Случайный,удаление,0.3245999996579485
+HashTable,Случайный,формирование списка,48.608699999022065
+HashTable,Упорядоченный,вставка,17.124399999374873
+HashTable,Упорядоченный,поиск,0.2822999995260034
+HashTable,Упорядоченный,удаление,0.31680000029155053
+HashTable,Упорядоченный,формирование списка,47.660199999882025
+HashTable,Случайный,вставка,16.860599998835823
+HashTable,Случайный,поиск,0.27319999935571104
+HashTable,Случайный,удаление,0.31459999991056975
+HashTable,Случайный,формирование списка,48.28310000084457
+HashTable,Упорядоченный,вставка,17.49010000094131
+HashTable,Упорядоченный,поиск,0.29379999978118576
+HashTable,Упорядоченный,удаление,0.31820000003790483
+HashTable,Упорядоченный,формирование списка,48.560000001089065
+BinarySearchTree,Случайный,вставка,53.984700000000885
+BinarySearchTree,Случайный,поиск,0.7683999992877943
+BinarySearchTree,Случайный,удаление,0.6331000004138332
+BinarySearchTree,Случайный,формирование списка,0.01739999970595818
+BinarySearchTree,Упорядоченный,вставка,163.88949999964098
+BinarySearchTree,Упорядоченный,поиск,1.765700000760262
+BinarySearchTree,Упорядоченный,удаление,1.525900001070113
+BinarySearchTree,Упорядоченный,формирование списка,0.4360000002634479
+BinarySearchTree,Случайный,вставка,52.91410000063479
+BinarySearchTree,Случайный,поиск,0.7721999991190387
+BinarySearchTree,Случайный,удаление,0.5829000001540408
+BinarySearchTree,Случайный,формирование списка,0.04259999877831433
+BinarySearchTree,Упорядоченный,вставка,164.1801999994641
+BinarySearchTree,Упорядоченный,поиск,1.7733000004227506
+BinarySearchTree,Упорядоченный,удаление,1.3930999994045123
+BinarySearchTree,Упорядоченный,формирование списка,0.8812000014586374
+BinarySearchTree,Случайный,вставка,52.482299999610404
+BinarySearchTree,Случайный,поиск,0.7862000002205605
+BinarySearchTree,Случайный,удаление,0.6584999991900986
+BinarySearchTree,Случайный,формирование списка,0.0718000010238029
+BinarySearchTree,Упорядоченный,вставка,161.70600000077684
+BinarySearchTree,Упорядоченный,поиск,1.7728999991959427
+BinarySearchTree,Упорядоченный,удаление,1.7010999999911292
+BinarySearchTree,Упорядоченный,формирование списка,1.2267000001884298
+BinarySearchTree,Случайный,вставка,53.89560000003257
+BinarySearchTree,Случайный,поиск,0.7697999990341486
+BinarySearchTree,Случайный,удаление,0.669999999445281
+BinarySearchTree,Случайный,формирование списка,0.1666999996814411
+BinarySearchTree,Упорядоченный,вставка,160.7681000004959
+BinarySearchTree,Упорядоченный,поиск,1.770599999872502
+BinarySearchTree,Упорядоченный,удаление,1.4972999997553416
+BinarySearchTree,Упорядоченный,формирование списка,1.454899998861947
+BinarySearchTree,Случайный,вставка,52.44479999964824
+BinarySearchTree,Случайный,поиск,0.7471999997505918
+BinarySearchTree,Случайный,удаление,0.7040000000415603
+BinarySearchTree,Случайный,формирование списка,0.19189999875379726
+BinarySearchTree,Упорядоченный,вставка,162.21529999893392
+BinarySearchTree,Упорядоченный,поиск,1.835400000345544
+BinarySearchTree,Упорядоченный,удаление,1.5229000000545057
+BinarySearchTree,Упорядоченный,формирование списка,1.444699999410659
+BinarySearchTree,Случайный,вставка,52.532899999278015
+BinarySearchTree,Случайный,поиск,0.772299999880488
+BinarySearchTree,Случайный,удаление,0.6493000000773463
+BinarySearchTree,Случайный,формирование списка,0.3001000004587695
+BinarySearchTree,Упорядоченный,вставка,162.3187000004691
+BinarySearchTree,Упорядоченный,поиск,1.7641000013099983
+BinarySearchTree,Упорядоченный,удаление,1.656399999774294
+BinarySearchTree,Упорядоченный,формирование списка,1.9058000016229926
+BinarySearchTree,Случайный,вставка,52.441100000578444
+BinarySearchTree,Случайный,поиск,0.7502000007661991
+BinarySearchTree,Случайный,удаление,0.7283999984792899
+BinarySearchTree,Случайный,формирование списка,0.4217999994580168
+BinarySearchTree,Упорядоченный,вставка,163.2737999989331
+BinarySearchTree,Упорядоченный,поиск,1.7657999997027218
+BinarySearchTree,Упорядоченный,удаление,1.2108999999327352
+BinarySearchTree,Упорядоченный,формирование списка,1.5694999983679736
+BinarySearchTree,Случайный,вставка,52.80719999973371
+BinarySearchTree,Случайный,поиск,0.7774999994580867
+BinarySearchTree,Случайный,удаление,0.5965999989712145
+BinarySearchTree,Случайный,формирование списка,0.4585999995470047
+BinarySearchTree,Упорядоченный,вставка,164.02340000058757
+BinarySearchTree,Упорядоченный,поиск,1.836600000387989
+BinarySearchTree,Упорядоченный,удаление,1.7723999990266748
+BinarySearchTree,Упорядоченный,формирование списка,2.3199999995995313
+BinarySearchTree,Случайный,вставка,52.927000000636326
+BinarySearchTree,Случайный,поиск,0.7868000011512777
+BinarySearchTree,Случайный,удаление,0.6422000005841255
+BinarySearchTree,Случайный,формирование списка,0.4780999988724943
+BinarySearchTree,Упорядоченный,вставка,162.5091000005341
+BinarySearchTree,Упорядоченный,поиск,1.8755000000965083
+BinarySearchTree,Упорядоченный,удаление,1.8066000011458527
+BinarySearchTree,Упорядоченный,формирование списка,2.217999999629683
+BinarySearchTree,Случайный,вставка,53.06439999912982
+BinarySearchTree,Случайный,поиск,0.7920999996713363
+BinarySearchTree,Случайный,удаление,0.7385999997495674
+BinarySearchTree,Случайный,формирование списка,0.6822999985161005
+BinarySearchTree,Упорядоченный,вставка,162.1802999998181
+BinarySearchTree,Упорядоченный,поиск,1.9329999995534308
+BinarySearchTree,Упорядоченный,удаление,1.5555000009044306
+BinarySearchTree,Упорядоченный,формирование списка,0.0028387000002112472

lukovnikovde/docs/report.md

@@ -0,0 +1,52 @@
+# Отчет по лабораторной работе "Структуры данных"
+## 1. Введение
+В ходе выполнения лабораторной работы были выполнены реализации трех структур для хранения и обработки данных телефонных номеров:
+- Связный список
+- Хеш-таблица
+- Двоичное дерево поиска.
+
+Практическая часть включала в себя такие операции как: добавление или обновление телефонного номера, удаление телефонного номера, поиск владельца телефонного номера и составление списка из кортежей вида (владелец, номер). Каждое выполнение функций проводилось с списоком из кортежей вида (владелецб номер), в котором было 1000 уникальных имен и еще 9000 имен, которые уже были использованны (всего 10000 кортежей). Каждое тестирование структур выполнялось для сортированного и не сортированного начального списка 10 раз.
+## 2. Результаты измерений
+Данные в таблице отражают среднее время в милисекундах выполнения структур. 
+| Структура | Начальный список | insert, мс | find, мс | delete, мс | create list, мс |
+| :---: | :---: | ---: | ---: | ---: | ---: |
+| LinkedList | not sorted |  165.61 | 1.767 | 3.418 | 31.795 |
+| LinkedList | sorted | 171.01 | 1.720 | 3.440 | 21.378 |
+| HashTable | not sorted | 17.15 | 0.278 | 0.320 | 48.080 |
+| HashTable | sorted | 17.49 | 0.284 | 0.321 | 47.911 |
+| BST | not sorted | 52.95 | 0.772 | 0.660 | 0.283 |
+| BST | sorted | 162.70 | 1.809 | 1.564 | 1.626 |
+
+Изходя  из полученных значений можно построить столбчатую диаграмму:
+
+![](data/time_schedule.png)
+## 3. Анализ полученных данных
+### 3.1 Зависимость скорости работы BST от порядка ввода данных.
+Из полученных данных можно заметить, что для BST порядок ввода сильно сказывается на результате скорости выполнения программы: при послутплении неотсортированных данных программа справляется примерно в 3 раза быстрее. Связано это с тем, что каждое новое значение, при сортированных данных, будет больше предыдущего, а соответственно будет каждый раз создаватся правый лист, из-за чего высота дерева становится равной количесвту всех уникальных имен, вседствии чего сложность возрастает до О(n), а двоичное дерево превращается в своебразный связный список. 
+
+### 3.2 Независимость скорости выполнения заполнения хеш-таблицы от порядка вводных данных
+Из эксперемента можно заметить, что скорость заполнения хеш-таблицы сортированными и несортированными данными почти одинакова(разница менее 2%). Это объясняется наличием бакетов, которые разбивают все данные на N списков (В данной лабораторной работе N = 100) и не зависмо от способа подачи данных мы всегда получим N списков с одинаков наполнением. 
+Скорость выполнения вставки почти одинакова, так как и для случая сортированного и несортированного начального списка необходимо только определить нужный бакет и добавить в этот бакет кортеж (владелец, номер), то есть сложность операции О(1), что отражают результаты эксперемента.
+Скорость выполнения поиска/удаления/составление списка почти одинаковы по тем же причинам: из-за наличия бакетов отрезаем часть лишних данных и уже работаем с оставшимеся, что значительно уменьшает время, а так как длина списока в бакете будет гораздо меньше длины списка исходных данных, что линейная сложность при переборе этого списка не сильно повлияет на время выполнения программы.
+
+### 3.3 Медленность посика связного списка
+Чтобы найти нужный элемент в связном списке необходимо перебрать все элементы стоящие до него, и если элемент находится где-то в конце такого списка, то придется перебрать почти все значения, на что уйдет явно больше премени чем при применениеи хеш-таблицы, которая отсекает большую часть ненужных данных, или двоичного дерева, которое составлено так, что не нужно будет перебирать все значения. 
+
+### 3.4 Принципы работы Удаления
+### - Связный список:
+В связном списке необходимо найти нужный словарь, значение ключа next содержит искомое имя. После этого мы меняем значение ключа next этого словаря на то, которое стоит в значении ключа next словаря, который мы собираемся удалить. Если мы хотим удалить запись, которой не существует, в таком случае перебираем весь связный спискок полностью и в случае ненахождения нужной записи возвращаем исходный список.
+
+### - Хеш-таблица:
+В начале ищем номер нужного бакета, и начинаем искать в бакете необходую запись: перебираем список кортежей, пока не найдем нужную запись. Если запись нашлась, то удалем ее и списка, если нет, то возвращаем исходные данные без изменений
+
+### - Двоичное дерево посика:
+Сначала ищем узел, который необходимо удалить, а затем действуем в зависимости от ситуации:
+- 1 У узла нет потомков:
+    В такой ситуации просто удаляем наш узел(в данном случае лист)
+- 2 У узла нет потомков справа или слева:
+    Если у узла есть только правые потомки, то на место этого узела помещаем узел, который расположен справа. Аналогично для случая с наличием левых потомков.
+- 3 Если у узла есть и правые и левые потомки:
+    Находим самый маленький узел в правом поддереве этого узла, то есть идем сначала вправо от узла, а потом только влево, пока не дойдем до значения None.
+    Копируем значения этого наименьшего и подставляем эти данные в узел, который хотим удалить, не меняя значения под ключами left и  right, а затем удаляем этот наименьший как описано в пунктах (1) и (2), так как этот узел или будет иметь только потомков вправа или не иметь их вообще
+
+## Вывод: в ходе выполнения лабораторной были изучены 3 способа хранения и обработки данных. Из данных полученных из эксперементов можно выделить наилучшие способы применения этих структур. Если в программе необходимо часто пополнять данные, корректировать, искать и удалять их, то лучше всего подойдет хеш-таблица. Если необходимо часто собирать все данные в один сортированный список и исходные данные несортированные, то хеш-таблица будет тормозить, в этом случае лучше использовать двоичное дерего поиска, хоть они и показывают более худший результат в добавлении, посике и удалении(примерно в 2.5-3 раза), но формируют список они моментально: 0.283 мс. Если же исходные данные отсортированны и необходимо выполнять все те же операции но без удаления, то в таком случае наиболее эффективным будет связный список.