2026-rff_mp/lukovnikovde/docs/data/DataStructure.py

import random as rnd
#############################################################################################

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 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):

    print('======== TESTING LL_INSERT ==========')
    Name = ['Dima', 'Ivan', 'Maxim', 'Alex', 'Olga', 'Lena']

    for _ in range(10):
        name = Name[rnd.randint(0, len(Name) - 1)]
        phone = str(rnd.randint(0,9)) + str(rnd.randint(0,9)) + str(rnd.randint(0,9)) + '-' + \
                str(rnd.randint(0,9)) + str(rnd.randint(0,9)) + str(rnd.randint(0,9)) 
        print(name, phone)
        head = ll_insert(head, name, phone)
        print(head)
        print('-----------------------------------\n')
    print('======== END TESTING ================\n\n')


    print('======== TESTING LL_FIND ==========') 
    Name.append('Masha')
    for i in range(len(Name)):
        name = Name[i]
        print(name, ":", ll_find(head, name))
    print("======== END TESTING =============\n\n")

    print("============ TESTING LL_LIST_ALL  AND SORT_LIST =============")
    print(*sort_list(ll_list_all(head)))
    print("============ END TESTING ===============\n\n")

    print('========== TESTING LL_DELETE ==========')
    
    for _ in range(2):
        name = Name[rnd.randint(0, 4)]
        head = ll_delete(head, name)

        print(head)
        print(name, ":", ll_find(head, name))
    print("========= END TESTING ==============\n\n")

#########################################################################################################

def ht_insert(buckest, name, phone):
    index = hash_key(name) % 10
    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) % 10
    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) % 10
    for i, (Name, Phone) in enumerate(buckest[index]):
        if Name == name:
            del buckest[index][i]
    return buckest


####################################################################################################

def HashTable(buckest):

    print('=========== TESTING HT_INSERT =============')
    Name = ['Dima', 'Alex', 'Ivan', 'Maxim', 'Olga', 'Lena']

    for _ in range(10):
        name = Name[rnd.randint(0, len(Name) - 1)]
        phone = str(rnd.randint(0,9)) + str(rnd.randint(0,9)) + str(rnd.randint(0,9)) + '-' + \
                str(rnd.randint(0,9)) + str(rnd.randint(0,9)) + str(rnd.randint(0,9))

        print(name, phone)
        buckest = ht_insert(buckest, name, phone)
        print(buckest)
        print('-----------------------------------------------------\n')
    
    print('============= END TESTING =====================\n\n')


    print('============== TESTING HT_FIND =====================')

    Name.append('Masha')
    for i in range(len(Name)):
        name = Name[i]
        print(name, ":", ht_find(buckest, name))
    print("======== END TESTING =============\n\n")

    print("================ TESTING TH_LIST_ALL ====================")

    print(*ht_list_all(buckest))
    print("========= END TESTING ==============\n\n")


    print('========== TESTING HT_DELETE ==========')
    
    for _ in range(2):
        name = Name[rnd.randint(0, len(Name) - 1)]
        buckest = ht_delete(buckest, name)

        print(buckest)
        print(name, ":", ht_find(buckest, name))
    print("========= END TESTING ==============\n\n")

#################################################################################################

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):
    
    running = root
    
    while running is not None:
        node = hash_key(running['name'])
        sheet = hash_key(name)
        if name == running['name']:
            
            break
        elif node < sheet:
            old_running = running
            flag = 1
            running = running['right']
        else:
            old_running = running
            flag = 0
            running = running['left']   
            
    step = ['left', 'right']        
            
    if running['left'] is None:
        old_running[step[flag]] = running['right']
        return root
    
    if running['right'] is None:
        old_running[step[flag]] = running['left']  
        return root
    
    node_delete = running
    old_running = running
    running = running['right']
    while running['left'] is not None:
        old_running = running
        running = running['left']
    
    node_delete['name'] = running['name']
    node_delete['phone'] = running['phone']
    old_running['left'] = None
          
    return root
    
#################################################################################################

def BinarySearchTree(root):

    print('=========== TESTING BST_INSERT =============')
    Name = ['Dima', 'Alex', 'Ivan', 'Maxim', 'Olga', 'Lena']

    for _ in range(10):
        name = Name[rnd.randint(0, len(Name) - 1)]
        phone = str(rnd.randint(0,9)) + str(rnd.randint(0,9)) + str(rnd.randint(0,9)) + '-' + \
                str(rnd.randint(0,9)) + str(rnd.randint(0,9)) + str(rnd.randint(0,9))

        print(name, phone)
        root = bst_insert(root, name, phone)
        print(root)
        print('-----------------------------------------------------\n')
    
    print('============= END TESTING =====================\n\n')

    print('============== TESTING BST_FIND =====================')

    Name.append('Masha')
    for i in range(len(Name)):
        name = Name[i]
        print(name, ":", bst_find(root, name))
    print("======== END TESTING =============\n\n")
    
    
    print('===================== TESTING BST_LIST_ALL =============')
    name_list = bst_list_all(root)
    print(*name_list)
    print("======== END TESTING =============\n\n")
    
    
    print('========== TESTING HT_DELETE ==========')
    
    for _ in range(2):
        name = Name[rnd.randint(0, len(Name) - 1)]
        root = bst_delete(root, name)

        print(root)
        print(name, ":", bst_find(root, name))
    print("========= END TESTING ==============\n\n")


################################################################################################
def main():
    
    LinkedList(None)
    HashTable([[] for _ in range(10)])
    BinarySearchTree(None)

if __name__ == "__main__":
    main()