def merge_sort(numbers):
if numbers.count() < 2:
return numbers
left, right = DoubleLinkedList(), DoubleLinkedList()
node = numbers.begin
length = numbers.count()
count = 0
while node:
# print("node>>>>", node.value)
if count < length // 2:
# print("left>>>", left)
left.shift(node.value)
else:
# print("right>>>", right)
right.shift(node.value)
count += 1
node = node.next
left = merge_sort(left)
right = merge_sort(right)
return merge(left, right)
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())
def merge(left, right):
# var result := empty list
rc = DoubleLinkedList()
# while left is not empty and right is not empty do
while left.begin and right.begin:
# if first(left) ≤ first(right) then
if left.begin.value <= right.begin.value:
# append first(left) to result
# left := rest(left)
rc.push(left.unshift())
# else
else:
# append first(right) to result
# right := rest(right)
rc.push(right.unshift())
# while left is not empty do
while left.begin:
# append first(left) to result
# left := rest(left)
rc.push(left.unshift())
# while right is not empty do
while left.begin:
# append first(right) to result
#right := rest(right)
rc.push(right.unshift())
# return result
return rc
class DListRouter(URLRouter):
def __init__(self):
self.urls = DoubleLinkedList()
def add(self, url, value):
self.urls.push(URLNode(url, value))
def exact_match(self, url):
node = self.urls.begin
while node:
route = node.value
if route.key == url:
return route.value
else:
node = node.next
return None
def match_all(self, url):
node = self.urls.begin
results = []
while node:
route = node.value
if len(route.key) > len(url):
if route.key.startswith(url):
results.append(route)
else:
if url.startswith(route.key):
results.append(route)
node = node.next
return results
class Dictionary(object):
def __init__(self, num_buckets=256):
"""Initializes a Map with the given number of buckets. 更多的buckets的目的是在于加速get_slot搜索过程！！！"""
self.map = DoubleLinkedList()
self.num_buckets = num_buckets
for i in range(0, self.num_buckets):
self.map.push(DoubleLinkedList())
def get_bucket(self, key):
"""Given a key, find the bucket where it would go."""
bucket_id = hash(key) % self.num_buckets
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
while node:
if key == node.value[0]:
return bucket, node
else:
node = node.next
# 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, node = self.get_slot(key)
bucket.detach(node)
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
def __init__(self, x: int, y: int, startLength: int):
self.__snake = DoubleLinkedList()
pixel = _Pixel(x, y, 's')
for i in range(startLength):
self.__snake.addBack(pixel)
pixel = pixel.right()
self.__direction = _Direction(random.randint(0, 2))
self.__grow = False
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 random_list(count):
numbers = DoubleLinkedList()
for i in range(count):
numbers.push(randint(1, max_numbers * 10))
#numbers.dump("after adding random_list()")
return numbers
def __init__(self, num_buckets=256):
"""Initializes a Map with the given number of buckets."""
# save to init List
# make buckets which has List
self.num_buckets = num_buckets
self.map = DoubleLinkedList()
for i in range(num_buckets):
self.map.push(DoubleLinkedList())
def copy_sublist(target_list: DoubleLinkedList, dest_list: DoubleLinkedList,
dest_size: int) -> DoubleLinkedList:
i = 0
while i < dest_size:
nodeval = target_list.unshift()
dest_list.push(nodeval)
i += 1
return dest_list # not needed; list is altered in-place
def copy_sublist(target_list: DoubleLinkedList, dest_list: DoubleLinkedList,
dest_size: int) -> DoubleLinkedList:
i = 0
while i < dest_size:
nodeval = target_list.unshift()
dest_list.push(nodeval)
i += 1
return dest_list
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)
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 test_remove_back():
list = DoubleLinkedList()
list.addFront('Last').addFront('First')
assert list.removeBack() == "Last"
assert list.front() == "First"
assert list.back() == "First"
assert list.removeBack() == "First"
assert list.isEmpty()
class Queue(object):
def __init__(self):
self.list = DoubleLinkedList()
def shift(self, obj):
"""Shifts a new element onto the back of the queue."""
self.list.shift()
def unshift(self):
"""Removes the element that is first in the queue."""
self.list.unshift()
class Queue:
def __init__(self):
self.__list = DoubleLinkedList()
def isEmpty(self):
return self.__list.isEmpty()
def add(self, element):
self.__list.addBack(element)
return self
def remove(self):
return self.__list.removeFront()
def merge(left, right):
result = DoubleLinkedList()
while left.count() != 0 and right.count() != 0:
if left.begin.value <= right.begin.value:
result.push(left.unshift())
else:
result.push(right.unshift())
while left.count() != 0:
result.push(left.unshift())
while right.count() != 0:
result.push(right.unshift())
return result
def merge_sort(list, lvl=0):
#print("merge_sort")
list_n = list.count()
if (list_n <= 1):
return
_left = DoubleLinkedList()
_right = DoubleLinkedList()
#print("list_N:", list_n)
for i in range(0, int(list_n/2), 1):
#print("__Left:", i)
_left.push(list.pop())
for i in range(int(list_n/2), list_n, 1):
#print("__Right:", i)
_right.push(list.pop())
#_left.dump("\t"*3*lvl + "before__sort____LEFT")
merge_sort(_left, lvl + 1)
#_left.dump("\t"*3*lvl + "after___sort____LEFT")
#_right.dump("\t"*3*lvl + "before__sort____RIGHT")
merge_sort(_right, lvl + 1)
#_right.dump("\t"*3*lvl + "after___sort____RIGHT")
#_left.dump("\t"*3*lvl + "________LEFT")
#_right.dump("\t"*3*lvl + "________RIGHT")
merge(_left, _right, list)
def merge_sort(numbers):
# function merge_sort(list m)
count = numbers.count()
if count <= 1:
# if length of m ≤ 1 then
return numbers
# return m
# var left := empty list
left_numbers = DoubleLinkedList()
# var right := empty list
right_numbers = DoubleLinkedList()
# for each x with index i in m do
i = 0
node = numbers.begin
# if i < (length of m)/2 then
# add x to left
for i in range(0, count):
# print(">>> i=", i)
rc = node.value
if i < (count // 2):
left_numbers.push(rc)
# else
# add x to right
else:
right_numbers.push(rc)
node = node.next
# left := merge_sort(left)
left_numbers = merge_sort(left_numbers)
# right := merge_sort(right)
right_numbers = merge_sort(right_numbers)
# return merge(left, right)
return merge(left_numbers, right_numbers)
class DLLRouter(URLRouter):
def __init__(self):
self.urls = DoubleLinkedList()
def add(self, key, value):
result = self.urls.push(URLNode(key, value))
return result
def match_url(self, url_to_find):
if self.urls.begin == None: return None
cur = self.urls.begin
while cur:
if cur.value.key == url_to_find:
return cur.value.value
else:
cur = cur.next
return None
def url_starts_with(self, url_to_find):
if self.urls.begin == None: return None
results = []
cur = self.urls.begin
while cur != self.urls.end:
if cur.value.key.startswith(url_to_find):
results.append(cur.value.value)
cur = cur.next
return results
def test_all():
numbers = [randint(0, 10000) for i in range(max_num)]
numbers_m = DoubleLinkedList()
numbers_b = DoubleLinkedList()
for i in numbers:
numbers_m.shift(i)
numbers_b.shift(i)
quick_sort(numbers, 0, max_num-1)
merge_sort(numbers_m)
bubble_sort(numbers_b)
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)
def test_copy():
list = DoubleLinkedList()
list.addFront(1).addFront(2).addFront(3)
copy = list.copy()
assert not copy == list
assert list.front() == 3
assert copy.front() == 3
assert copy.removeBack() == 1
assert copy.back() == 2
assert list.back() == 1
def random_dll_list(count):
numbers = DoubleLinkedList()
for i in range(count, 0, -1):
# print(i)
numbers.shift(randint(0, 10000))
numbers.dump()
return numbers
def merge(left, right):
result = DoubleLinkedList()
# if left == None: return right
# if right == None: return left
while left.count() != 0 and right.count() != 0:
if left.get(0) < right.get(0):
# val = left.unshift()
result.shift(left.unshift())
# left.detach_node(left.begin)
# print("left-count:", left.count())
else:
# val = right.unshift()
result.shift(right.unshift())
# right.detach_node(right.begin)
# result.shift(val)
# print(result.unshift())
while left.count() != 0:
# val = left.unshift()
# result.shift(val)
result.shift(left.unshift())
# left.detach_node(left.begin)
while right.count() != 0:
# val = right.unshift()
# result.shift(val)
result.shift(right.unshift())
# right.detach_node(right.begin)
test = result.begin
while test:
print(test.value)
test = test.next
return result
def random_list(count):
numbers = DoubleLinkedList()
for i in range(count):
numbers.push( randint(1, 100) )
numbers.dump("after random_list()")
return numbers
class DListRouter(URLRouter):
def __init__(self):
self.urls = DoubleLinkedList()
def add(self, url, value):
self.urls.push(URLNode(url, value))
def exact_match(self, url):
node = self.urls.begin
while node:
route = node.value
if route.key == url:
return route.value
else:
node = node.next
return None
def match_all(self, url):
node = self.urls.begin
results = []
while node:
route = node.value
if len(route.key) > len(url):
if route.key.startswith(url):
results.append(route)
else:
if url.startswith(route.key):
results.append(route)
node = node.next
return results
def merge(left, right):
ret = DoubleLinkedList()
ln = left.begin
rn = right.begin
while (ln and rn):
if (ln.value < rn.value):
ret.push(ln.value)
ln = ln.next
else:
ret.push(rn.value)
rn = rn.next
while (ln):
ret.push(ln.value)
ln = ln.next
while (rn):
ret.push(rn.value)
rn = rn.next
return ret
def partition(dllist: DoubleLinkedList, lo: int, hi: int) -> int:
pivot = dllist.get(hi)
index = small_index = lo
while index < hi:
if get_node(dllist, index).value < pivot:
temp_i = get_node(dllist, small_index)
temp_j = get_node(dllist, index)
temp_i.value, temp_j.value = temp_j.value, temp_i.value
small_index += 1
index += 1
temp_i = get_node(dllist, small_index)
temp_hi = get_node(dllist, hi)
temp_i.value, temp_hi.value = temp_hi.value, temp_i.value
return small_index
def partition(dllist: DoubleLinkedList, lo: int, hi: int) -> int:
"""performance: get_node called too many times."""
pivot = dllist.get(hi)
index = small_index = lo
while index < hi:
if get_node(dllist, index).value < pivot:
temp_i = get_node(dllist, small_index)
temp_j = get_node(dllist, index)
temp_i.value, temp_j.value = temp_j.value, temp_i.value
small_index += 1
index += 1
# performance: can we eliminate these? (get_node())
temp_i = get_node(dllist, small_index)
temp_hi = get_node(dllist, hi)
temp_i.value, temp_hi.value = temp_hi.value, temp_i.value
return small_index
def merge(left, right):
result = DoubleLinkedList()
print("<<< entering merge...")
print(
f"<<< before while, left is {left.begin}, and right is {right.begin}.")
while left is not None and right is not None: # while both slists are not empty
print(f"<<< enter while - left=", left.begin, "right=", right.begin)
if left.begin.value <= right.begin.value:
print("<<< if-branch: left=", left.begin, "right=", right.begin)
result.push(left.unshift())
print("<<< result=", result.dump("result"))
else:
print("<<< else-branch: left=", left.begin, "right=", right.begin)
result.shift(right.unshift())
print("<<< result=", result.dump("result"))
print(
f"<<< after 1st while - left is {left.begin}, and right is {right.begin}."
)
print("<<< result=", result)
while left:
result.shift(left.unshift())
while right:
result.shift(right.unshift())
return result
def __init__(self):
self.list = DoubleLinkedList()
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
def random_list(count):
numbers = DoubleLinkedList()
for i in range(count, 0, -1):
numbers.shift(randint(0, 10000))
return numbers
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 __init__(self):
self.urls = DoubleLinkedList()
