import random as rnd


# СВЯЗНЫЙ СПИСОК


def ll_insert(head, name, phone):
    new_node = {'name': name, 'phone': phone, 'next': None}
    
    if head is None:
        return new_node
        
    current = head
    while current is not None:
        if current['name'] == name:
            current['phone'] = phone
            return head
        if current['next'] is None:
            break
        current = current['next']
        
    current['next'] = new_node
    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 sort_records(lst):
    n = len(lst)
    for i in range(n):
        for j in range(0, n-i-1):
            if lst[j][0] > lst[j + 1][0]:
                lst[j], lst[j + 1] = lst[j + 1], lst[j]
    return lst

def ll_list_all(head):
    record = []
    current = head
    while current is not None:
        record += [(current['name'], current['phone'])]
        current = current['next']
    res = sort_records(record)
    return res


# 2. ХЕШ-ТАБЛИЦА


def def_hash(name, size):
    hash_value = 0
    for char in name:
        hash_value += ord(char)
    final_idx = hash_value % size
    return final_idx

def ht_insert(buckets, name, phone):
    size = len(buckets)
    idx = def_hash(name, size)
    buckets[idx] = ll_insert(buckets[idx], name, phone)
    return buckets

def ht_find(buckets, name):
    size = len(buckets)
    idx = def_hash(name, size)
    return ll_find(buckets[idx], name)

def ht_delete(buckets, name):
    size = len(buckets)
    idx = def_hash(name, size)
    buckets[idx] = ll_delete(buckets[idx], name)
    return buckets

def ht_list_all(buckets):
    res = []
    for head in buckets:
        current = head
        while current is not None:
            res += [(current['name'], current['phone'])]
            current = current['next']
    return sort_records(res)


# ДВОИЧНОЕ ДЕРЕВО ПОИСКА


def bst_insert(root, name, phone):
    new_node = {'name': name, 'phone': phone, 'left': None, 'right': None}
    
    if root is None:
        return new_node
        
    current = root
    while True:
        if name == current['name']:
            current['phone'] = phone  
            break
        elif name < current['name']:
            if current['left'] is None:
                current['left'] = new_node
                break
            current = current['left']
        else:
            if current['right'] is None:
                current['right'] = new_node
                break
            current = current['right']
            
    return root

def bst_find(root, name):
    current = root
    while current is not None:
        if name == current['name']:
            return current['phone']
        elif name < current['name']:
            current = current['left']
        else:
            current = current['right']
    return None

def bst_delete(root, name):
    if root is None:
        return None
        
    p_node = None
    current = root
    
    while current is not None and current['name'] != name:
        p_node = current
        if name < current['name']:
            current = current['left']
        else:
            current = current['right']
            
    if current is None:
        return root
        
    if current['left'] is None and current['right'] is None:
        if p_node is None:
            return None
        if p_node['left'] is current:
            p_node['left'] = None
        else:
            p_node['right'] = None
        return root

    if current['left'] is None:
        c_node = current['right']
    elif current['right'] is None:
        c_node = current['left']
    else:
        succ_parent = current
        succ = current['right']
        while succ['left']:
            succ_parent = succ
            succ = succ['left']
            
        current['name'], current['phone'] = succ['name'], succ['phone']
        
        if succ_parent['left'] is succ:
            succ_parent['left'] = succ['right']
        else:
            succ_parent['right'] = succ['right']
        return root
        
    if p_node is None:
        return c_node
    if p_node['left'] is current:
        p_node['left'] = c_node
    else:
        p_node['right'] = c_node
    return root

def bst_list_all(root):
    record = []
    
    def helper(node):
        if node is not None:
            helper(node['left'])
            nonlocal record
            record += [(node['name'], node['phone'])]
            helper(node['right'])
            
    helper(root)
    return record


# ЭКСПЕРИМЕНТАЛЬНАЯ ЧАСТЬ 


if __name__ == '__main__':
    N = 10000
    

    records = []
    for i in range(N):

        name = f"User_{i:05d}"
        phone = f"+7-{rnd.randint(100, 999)}-{rnd.randint(100, 999)}-{rnd.randint(1000, 9999)}"
        records.append((name, phone))
        

    records_shuffled = records[:]
    rnd.shuffle(records_shuffled) 
    

    records_sorted = sorted(records, key=lambda x: x[0])
    
    print(f" Бетта-тест")
    print(f"records_shuffled (первые 3): {records_shuffled[:3]}")
    print(f"records_sorted (первые 3): {records_sorted[:3]}")