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