348 lines
9.9 KiB
Python
348 lines
9.9 KiB
Python
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()
|
|
|
|
|
|
|
|
|