def merge_sort(dllist: DoubleLinkedList) -> DoubleLinkedList:
# if dllist.count() == 1:
if dllist.begin.next == None:
print(">>> base case: dllist=", dllist.dump("base case"))
return dllist
left = DoubleLinkedList() # using new dllist to copy each smaller list
right = DoubleLinkedList()
middle = dllist.count() // 2
print(">>> middle=", middle)
lsize = middle
print(">>> lsize=", lsize)
rsize = dllist.count() - middle
print(">>> rsize=", rsize)
copy_sublist(dllist, left, lsize)
copy_sublist(dllist, right, rsize)
left = merge_sort(left)
print(">>> ", left.dump("left="))
right = merge_sort(right)
print(">>> will this even run? right=", right.dump("right="))
return merge(left, right)
def merge_sort(dllist: DoubleLinkedList) -> DoubleLinkedList:
if dllist.count() == 1:
return dllist
left = DoubleLinkedList() # using new dllist to copy each smaller list
right = DoubleLinkedList()
middle = dllist.count() // 2
lsize = middle
rsize = dllist.count() - middle
copy_sublist(dllist, left, lsize)
copy_sublist(dllist, right, rsize)
left = merge_sort(left)
right = merge_sort(right)
return merge(left, right)
class Dictionary(object):
def __init__(self, num_buckets=256):
self.map = DoubleLinkedList()
for x in range(0, num_buckets):
self.map.push(DoubleLinkedList())
def hash_key(self, key):
return hash(key) % self.map.count()
def get_bucket(self, key):
bucket_id = self.hash_key(key)
return self.map.get(bucket_id)
def get_slot(self, key):
bucket = self.get_bucket(key)
if bucket:
slot = bucket.begin
while slot:
if key == slot.value[0]:
return bucket, slot
else:
slot = slot.next
return bucket, None
def get(self, key, default=None):
bucket, slot = self.get_slot(key)
return slot and slot.value[1] or default
def set(self, key, value):
bucket, slot = self.get_slot(key)
if slot:
slot.value = (key, value)
else:
bucket.push((key, value))
def delete(self, key):
bucket = self.get_bucket(key)
slot = bucket.begin
while slot:
k, v = slot.value
if key == k:
bucket.detach_node(slot)
break
def print_list(self):
bucket_node = self.map.begin
while bucket_node:
slot_node = bucket_node.value.begin
while slot_node:
print(slot_node.value)
slot_node = slot_node.next
bucket_node = bucket_node.next
def main():
number = randint(5, 10)
start_list = DoubleLinkedList()
left = DoubleLinkedList()
right = DoubleLinkedList()
for i in range(number):
start_list.push(randint(0, 10))
start_list.dump("start list initialized.")
lsize = start_list.count()
print("\nlsize is: ", lsize)
mid = lsize // 2
print("\nmid is: ", mid)
left_size = mid
right_size = lsize - mid
print(f"\nThe length of left is {left_size} & right is {right_size}.")
# copy half of the list into left
# i = 0
# while i < mid:
# nodeval = start_list.unshift()
# left.push(nodeval)
# i += 1
# replace above while block with a function call:
copy_sublist(start_list, left, mid)
start_list.dump("start after left copy")
left.dump("left after copying from start")
j = 0
while j < right_size:
# print(">>> start of while: j is", j, " and right_size is", right_size)
nodeval = start_list.unshift()
# print(">>> nodeval is ", nodeval)
right.push(nodeval)
# right.dump(f"right at {j} is ")
j += 1
print()
start_list.dump("start after right copy")
print()
right.dump("right after copying from start")
print()
class Dictionary(object):
def __init__(self, num_buckets=256):
"""Initializes a Map with the given number of buckets."""
self.map = DoubleLinkedList()
for i in range(0, num_buckets):
self.map.push(DoubleLinkedList())
def hash_key(self, key):
"""Given a key this will create a number and then convert it to
an index for the aMap's buckets."""
return hash(key) % self.map.count()
def get_bucket(self, key):
"""Given a key, find the bucket where it would go."""
bucket_id = self.hash_key(key)
return self.map.get(bucket_id)
def get_slot(self, key, default=None):
"""
Returns either the bucket and node for a slot, or None, None
"""
bucket = self.get_bucket(key)
if bucket:
node = bucket.begin
i = 0
while node:
if key == node.value[0]:
return bucket, node
else:
node = node.next
i += 1
# fall through for both if and while above
return bucket, None
def get(self, key, default=None):
"""Gets the value in a bucket for the given key, or the default."""
bucket, node = self.get_slot(key, default=default)
return node and node.value[1] or node
def set(self, key, value):
"""Sets the key to the value, replacing any existing value."""
bucket, slot = self.get_slot(key)
if slot:
# the key exists, replace it
slot.value = (key, value)
else:
# the key does not, append to create it
bucket.push((key, value))
def delete(self, key):
"""Deletes the given key from the Map."""
bucket = self.get_bucket(key)
node = bucket.begin
while node:
k, v = node.value
if key == k:
bucket.detach_node(node)
break
def list(self):
"""Prints out what's in the Map."""
bucket_node = self.map.begin
while bucket_node:
slot_node = bucket_node.value.begin
while slot_node:
print(slot_node.value)
slot_node = slot_node.next
bucket_node = bucket_node.next
class Dictionary(object):
def __init__(self, num_buckets=256):
self.map = DoubleLinkedList()
for i in range(0, num_buckets):
self.map.push(DoubleLinkedList())
def hash_key(self, key):
"""
Takes key and creates number and index for a map's buckets.
The hash() method returns the hash value of an object if it has one. Hash values are just integers which are used to compare dictionary keys during a dictionary lookup quickly
"""
return hash(key) % self.map.count()
def get_bucket(self, key):
"""
Return bucket given a key
"""
bucket_id = self.hash_key(key)
return self.map.get(bucket_id)
def get_slot(self, key, default=None):
"""
Returns bucket and node for slot
"""
bucket = self.get_bucket(key)
if bucket:
node = bucket.begin
i = 0
while node:
if key == node.value[0]:
return bucket, node
else:
node = node.next
i += 1
# fall through for both if and while
return bucket, None
def get(self, key, default=None):
"""
Gets value in bucket for given key
"""
bucket, node = self.get_slot(key, default=default)
return node and node.value[1] or node
def set(self, key, value):
"""
Sets ket to the value, replacing existing value
This returns the last DLL and sets the value at the end for a new entry
For an existing entry it finds the node within the list and replaces it with the tuple
"""
bucket, slot = self.get_slot(key)
if slot:
slot.value = (key, value)
else:
bucket.push((key, value))
def delete(self, key):
"""
Delete given key from map
"""
bucket = self.get_bucket(key)
node = bucket.begin
while node:
k, v = node.value
if key == k:
bucket.detach_node(node)
break
def list(self):
"""
Print out what's in Map
"""
bucket_node = self.map.begin
while bucket_node:
slot_node = bucket_node.value.begin
while slot_node:
print(slot_node.value)
slot_node = slot_node.next
bucket_node = bucket_node.next
class Dictionary(object):
def __init__(self, num_buckets=256):
"""Initializes a Map with the given number of buckets."""
self.map = DoubleLinkedList()
for i in range(0, num_buckets):
self.map.push(DoubleLinkedList())
def hash_key(self, key):
"""Given a key this will create a number and then convert it to
and index for the Map's buckets."""
return hash(key) % self.map.count()
def get_bucket(self, key):
"""Given a key, find the bucket where it would go."""
bucket_id = self.hash_key(key)
return self.map.get(bucket_id)
def get_slot(self, key, default=None):
"""Returns either the bucket and node for a slot, or None, None"""
bucket = self.get_bucket(key)
if bucket:
node = bucket.begin
i = 0
while node:
if key == node.value[0]:
return bucket, node
else:
node = node.next
i += 1
# fall through for both if and while above
return bucket, None
def get(self, key, default=None):
"""Gets the value in a bucket for a given key, or the default."""
bucket, node = self.get_slot(key, default=default)
return node and node.value[1] or node
def set(self, key, value):
"""Sets the key to the value, replacing any existing value."""
bucket, slot = self.get_slot(key)
if slot:
# the key exists, replace it
slot.value = (key, value)
else:
# the key does not, append to create it
bucket.push((key, value))
def delete(self, key):
"""Deletes the given key from the Map."""
bucket = self.get_bucket(key)
node = bucket.begin
while node:
k, v = node.value
if key == k:
bucket.detach_node(node)
break
def list(self):
"""Print out what's in the Map."""
bucket_node = self.map.begin
while bucket_node:
slot_node = bucket_node.value.begin
while slot_node:
print(slot_node.value)
slot_node = slot_node.next
bucket_node = bucket_node.next
class Dictionary(object):
def __init__(self,
num_buckets=256): # set number of bucktes to 256 ( 2 ** 8)
"""Initializes a Map with the given number of buckets."""
self.map = DoubleLinkedList(
) # self.map is DoubleLinkedList() with it's methods
for i in range(0, num_buckets):
self.map.push(DoubleLinkedList(
)) # now the parent map-dllist contains 256 child dllists
def hash_key(self, key):
"""Given a key this will create a number and then convert it to
an index for the aMap's buckets."""
return hash(key) % self.map.count(
) # create an index for a key - try print(states.hash_key('NY')) in test_dictionary.py
def get_bucket(self, key):
"""Given a key, find the bucket where it would go."""
bucket_id = self.hash_key(
key) # get the index of the bucket we want to access
return self.map.get(
bucket_id
) # get the bucket (parent dllist) at the given id (created with hash_key)
def get_slot(self, key, default=None):
"""
Returns either the bucket and node for a slot, or None, None
"""
bucket = self.get_bucket(
key) # find a bucket (get the index of a bucket)
if bucket: # if bucket exists
node = bucket.begin # set node to the begin of the parent dllist
i = 0 # what for?
while node: # traverse the parent dllist
if key == node.value[0]: # if key equals key stored in a node
return bucket, node # return dllist and key-value pair (node)
else: # if not, go further
node = node.next
i += 1
# fall through for both if and while above
return bucket, None
def get(self, key, default=None):
"""Gets the value in a bucket for a given key, or the default."""
bucket, node = self.get_slot(
key, default=default
) # get the right bucket (parent dllist) and the right node (key-value pair)
return node and node.value[1] or node # return key-value pair
def set(self, key, value):
"""Sets the key to the value, replacing any existing value."""
bucket, slot = self.get_slot(
key) # find a bucket and a slot at/inside this bucket
if slot:
# the key exists, replace it
slot.value = (key, value)
else:
# the key does not, append to create it
bucket.push((key, value))
def delete(self, key):
"""Deletes the given key from the Map."""
bucket = self.get_bucket(
key) # find a bucket (get the index of a bucket)
node = bucket.begin # we need to go through buckets
while node: # traverse the parent dllist
k, v = node.value # key-value pair set to the value of te node, key-value pair of the node
if key == k: # if key matches node's key
bucket.detach_node(
node) # detach the node from the parent dllist
break #stop
def list(self):
"""Prints out what's in the Map."""
bucket_node = self.map.begin # start at the beginning of the parent dllist
while bucket_node: # traverse the parent dllist
slot_node = bucket_node.value.begin # we need to access a child dllist
while slot_node: # traverse a child dllist
print(
slot_node.value
) # prints the key-value pair stored inside a slot, which is a node of a child dllist
slot_node = slot_node.next # go further inside a child dllist
bucket_node = bucket_node.next # go further inside the parent dllist
class Dictionary(object):
def __init__(self, num_buckets=256):
"""Inicjalizuje mapę z daną liczbą wiaderek"""
self.map = DoubleLinkedList()
for _ in range(0, num_buckets):
self.map.push(DoubleLinkedList())
def hash_key(self, key):
"""Dla danego klucza utworzy liczbę i przekonwertuje ją na
indeks dla wiaderek mapy"""
return hash(key) % self.map.count()
def get_bucket(self, key):
"""Dla danego klucza znajduje wiaderko, w którym powinien być umieszczony"""
bucket_id = self.hash_key(key)
return self.map.get(bucket_id)
def get_slot(self, key, default=None):
"""Zwraca wiaderko i węzeł dla slotu albo None, None"""
bucket = self.get_bucket(key)
if bucket:
node = bucket.begin
i = 0
while node:
if key == node.value[0]:
return bucket, node
else:
node = node.next
i += 1
# Przechodzi zarówno przez if, jak i while powyżej
return bucket, None
def get(self, key, default=None):
"""Pobiera wartość z wiaderka dla danego klucza lub wartość domyślną"""
bucket, node = self.get_slot(key, default=default)
return node and node.value[1] or node
def set(self, key, value):
"""Ustawia wartość dla klucza, zastępując istniejącą wartość"""
bucket, slot = self.get_slot(key)
if slot:
# Jeśli klucz istnieje, zastępuje go
slot.value = (key, value)
else:
# Jeśli klucz nie istnieje, dodaje go
bucket.push((key, value))
def delete(self, key):
"""Usuwa dany klucz z mapy"""
bucket = self.get_bucket(key)
node = bucket.begin
while node:
k, v = node.value
if key == k:
bucket.detach_node(node)
break
def list(self):
"""Wypisuje, co znajduje się w mapie"""
bucket_node = self.map.begin
while bucket_node:
slot_node = bucket_node.value.begin
while slot_node:
print(slot_node.value)
slot_node = slot_node.next
bucket_node = bucket_node.next
class Dictionary(object): def __init__(self, num_bucket = 256): self.map = DoubleLinkedList() for i in range(0, num_bucket): self.map.push(DoubleLinkedList()) """takes a key, convert it to number and get bucket id it will belong to""" def hash_key(self, key): return hash(key) % self.map.count() def get_bucket(self, key): bucket_id = self.hash_key(key) return self.map.get(bucket_id) def get_slot(self, key, default = None): """ return either a bucket and a node fro the slot , or None, None """ bucket = self.get_bucket(key) if bucket: node = bucket.begin i=0 while node: if key == node.value[0]: return bucket, node else : node = node.next i+=1 #fall through both if and while above return bucket, None def get(self, key, default = None): bucket, node = self.get_slot(key, default = default) return node and node.value[1] or node def set(self, key, value): bucket, slot = self.get_slot(key) if slot: slot.value = (key, value) else: bucket.push((key, value)) def delete(self, key): bucket = self.get_bucket(key) node = bucket.begin while node: k, v = node.value if key == k: bucket.detach_node(node) break def list(self): bucket_node = self.map.begin while bucket_node: slot_node = bucket_node.value.begin while slot_node: print(slot_node.value) slot_node = slot_node.next bucket_node = bucket_node.next
class Dictionary(object):
"""
python字典的数据结构，用双链表来实现
{bucket0,bucket1,bucket2,...,bucket256}
每个bucket也是一个双链表 [key<->value0<->value1<->value2<->...]
every bucket is a dllist
"""
def __init__(self, num_buckets=256):
"""Initializes a Map with the given number of buckets."""
self.map = DoubleLinkedList()
for i in range(num_buckets):
self.map.push(DoubleLinkedList())
def hash_key(self, key):
"""Given a key this will create a # and then convert it to an index for the
aMap's buckets.
给一个键，返回这个键对应的bucket的索引值在map里边"""
return hash(key) % self.map.count()
def get_bucket(self, key):
"""输入一个键，返回一个包含键值对的节点bucket"""
bucket_id = self.hash_key(key)
return self.map.get(bucket_id)
def get_slot(self, key, default=None):
"""
Returns either the bucket and node for a slot, or None, None
插槽
"""
# an instance of bucket implemented by dllist
bucket = self.get_bucket(key)
if bucket:
node = bucket.begin
i = 0
while node:
if key == node.value[0]:
return bucket, node
else:
node = node.next
i += 1
return bucket, None
def get(self, key, default=None):
"""Gets the value in a bucket for the given key, or the default."""
bucket, node = self.get_slot(key, default=default)
return node and node.value[1] or node
def set(self, key, value):
"""
字典dict的set方法实现
Sets the key to the value, replacing any existing value."""
bucket, slot = self.get_slot(key)
if slot:
# the key exists, replace it
slot.value = (key, value)
else:
# the key does not, append to create it
bucket.push((key, value))
def delete(self, key):
"""Deletes the given key from the Map."""
bucket = self.get_bucket(key)
node = bucket.begin
while node:
k, v = node.value
if key == k:
bucket.detach_node(node)
break
def list(self):
"""Prints out what's in the Map."""
bucket_node = self.map.begin
while bucket_node:
slot_node = bucket_node.value.begin
while slot_node:
print(slot_node.value)
slot_node = slot_node.next
bucket_node = bucket_node.next
class Dictionary(object):
def __init__(self, num_buckets=256):
"""Initializeds a Map with the given numbers of buckets"""
self.map = DoubleLinkedList()
# use map as dictory container. It's actually a DLL
for i in range(0, num_buckets):
# this DLL has 256 slots/buckets
self.map.push(DoubleLinkedList())
# put 256 DLL inside this map DLL
def hash_key(self, key):
"""Given a key this will create a number and then convert it to an index for the aMap's buckets."""
# transfer the "word key" to a "number key" using hash() function
return hash(key) % self.map.count()
def get_bucket(self, key):
"""Given a key, find the bucket where it would go."""
bucket_id = self.hash_key(key)
# return the number key
return self.map.get(bucket_id)
# using the number key, search through the map DLL and get the DLL(bucket) we need
def get_slot(self, key, default=None):
# return value is the bucket and node(slot) to locate.
"""Returns either the bucket and node for a slot, or None, None"""
bucket = self.get_bucket(key)
# using the key, through number key, get the reference to the DLL(bucket) we need
if bucket:
# make sure the bucket is not NULL? (Even it's a empty bucket DLL)
node = bucket.begin
# by default, will point to the first node
i = 0
# searching through this bucket DLL and find the node of same key. If
while node:
# as far as node is not empty, inside will be tuples... (key, value)
if key == node.value[0]:
# if key is same as tuple's first key
return bucket, node
# this is the node(tuple) we need. return current DLL(bucket) and Node(tuple)
else:
node = node.next
# else, search on the next node
i += 1
# fall through for both if and while above
return bucket, None
# security. When it will happen?
def get(self, key, default=None):
"""Gets the value in a bucket for a given key, or the default."""
bucket, node = self.get_slot(key, default=default)
return node and node.value[1] or node
def set(self, key, value):
"""Sets the key to the value, replacing and existing value."""
bucket, slot = self.get_slot(key)
if slot:
# the key exists, replace it
slot.value = (key, value)
else:
# the key does not, append to create it
bucket.push((key, value))
def delete(self, key):
"""Deletes the given key from the Map."""
bucket = self.get_bucket(key)
node = bucket.begin
while node:
k, v = node.value
if key == k:
bucket.detach_node(node)
break
def list(self):
"""Prints out what's in the Map."""
bucket_node = self.map.begin
while bucket_node:
slot_node = bucket_node.value.begin
while slot_node:
print(slot_node.value)
slot_node = slot_node.next
bucket_node = bucket_node.next
class Dictionary(object):
def __init__(self, num_buckets=256):
"""Initializes a Map with the given number of buckets."""
self.map = DoubleLinkedList() # create new dllist
# Create a new dllist for each bucket in the map
for i in range(0, num_buckets):
self.map.push(DoubleLinkedList())
def hash_key(self, key):
"""Given a key this will create a number and then convert it to
an index for the aMap's buckets."""
# uses a key to get a unique integer, modulus to get the index
return hash(key) % self.map.count()
def get_bucket(self, key):
"""Given a key, find the bucket where it would go."""
# gets index for a key and assigns it to a bucket
bucket_id = self.hash_key(key)
# uses index to get the value of the bucket (which is a dllist node)
return self.map.get(
bucket_id) # calls the dllist get() function! OMG!!
def get_slot(self, key, default=None):
"""
Returns either the bucket and node for a slot, or None, None
"""
# gets ref to the slot dllist for a given key
bucket = self.get_bucket(key) # slot not bucket right?
# if the slot in the bucket is not None
if bucket:
# initialize to first node in the slot dllist
node = bucket.begin # set to first node
i = 0
# traverse the slot dllist & check for keys existance
while node:
# if the key matches the first element of the key/value tuple
if key == node.value[0]:
return bucket, node # return the bucket and a ref to the slot / node
else:
node = node.next
i += 1 # not sure what this is for...
# fall through for both if and while above
return bucket, None # if key isn't already in the list
def get(self, key, default=None):
"""Gets the value in a bucket for the given key, or the default."""
# gets the bucket and slot for a given key
bucket, node = self.get_slot(key, default=default)
# ternary operation; if there's a node it returns
# it's value, if it exists, else the default (None)
return node and node.value[1] or default
def set(self, key, value):
"""Sets the key to the value, replacing any existing value."""
# gets the bucket and slot for a new key/value pair
bucket, slot = self.get_slot(key)
if slot:
# the key exists, replace it
slot.value = (key, value)
else:
# the key does not, append to create it
bucket.push((key, value))
def delete(self, key):
"""Deletes the given key from the Map."""
# gets the bucket (slot) for the key to be removed
bucket = self.get_bucket(key)
node = bucket.begin
# traverse the slot dllist
while node:
# unpack the tuple to get the key for comparison
k, v = node.value
# check if the keys match
if key == k:
# if so, remove the node and exit the loop
bucket.detach_node(node)
break
else: # otherwise, keep going
node = node.next
def list(self):
"""Prints out what's in the Map."""
# start at the first node of the map
bucket_node = self.map.begin
# iterate over the buckets
while bucket_node:
# get the first node of the slot list in the given bucket
slot_node = bucket_node.value.begin
# iterate through the slot list
while slot_node:
# print the value and get the next node
print(slot_node.value)
slot_node = slot_node.next
# get the next bucket
bucket_node = bucket_node.next
