class Queue(object): """Will create a instance of Queue and allow enqueue(), dequeue(), peek(), size() and len() methods to work.""" def __init__(self, iterable=None): """Will init a new instance of the Stack class.""" from dll import DoubleLinkedList self._dll = DoubleLinkedList() self._counter = 0 def enqueue(self, data): """Will push a new element into the Queue.""" self._dll.append(data) self._counter += 1 def dequeue(self): """Will remove the first element in the Queue.""" if self._dll.head: self._counter -= 1 return self._dll.pop() def peek(self): """Will return the next value in the Queue.""" return self._dll.head.data def __len__(self): """Will return the length of the stack using len().""" return self._counter
class Queue(object): """Class Queue for enqueue and dequeue data structure.""" def __init__(self): """Init for Queue.""" self._new_dll = DoubleLinkedList() def enqueue(self, val): """Enqueue function for queue pushes value to head.""" return self._new_dll.push(val) def dequeue(self): """Dequeue function for queue removes val from tail and returns val.""" return self._new_dll.shift() def peek(self): """Return a new value without dequeuing it.""" print(self._new_dll.tail.data) def size(self): """Length function for the queue.""" return self._new_dll.size() def __len__(self): """Length.""" return self._new_dll.size()
class Deque(object): """Class deque for deque composition.""" def __init__(self): """Init for deque.""" self._new_dll = DoubleLinkedList() def append(self, val): """Enqueue function for queue pushes value to head.""" return self._new_dll.push(val) def appendleft(self, val): """Append vals to the front of deque.""" return self._new_dll.append(val) def pop(self): """Pop from dll.""" return self._new_dll.pop() def popleft(self): """Shift for popleft.""" return self._new_dll.shift() def peek(self): # pragma no cover """Return a new value without dequeuing it.""" print(self._new_dll.head.data) def peekleft(self): # pragma no cover """Return a new value from the left without dequeing it.""" print(self._new_dll.tail.data) def __len__(self): """Length function for the queue.""" return len(self._new_dll)
def test_4(self): """check that head is still the first node added to list""" n1 = Node('A') n2 = Node('B') dl = DoubleLinkedList() dl.append(n1) dl.append(n2) self.assertEqual(dl.head._value, 'A')
def test_3(self): """add two nodes. test that 2nd append makes changes tail to new node""" n1 = Node('A') n2 = Node('B') dl = DoubleLinkedList() dl.append(n1) dl.append(n2) self.assertEqual(dl.tail._value, 'B')
def test_4(self): """ test that tail.next returns none """ dl = DoubleLinkedList() n1 = Node(5) n2 = Node(3) dl.append(n1) dl.append(n2) self.assertEqual(dl.tail._next, None)
def __init__(self, num_buckets=256): """Initializes a Map with the given number of buckets.""" # the map is a DLL self.map = DoubleLinkedList() # we add a DLL for every bucket so now we have # a big DLL containing other tiny DLLs - containers # for the key -value tuples for i in range(0, num_buckets): self.map.push(DoubleLinkedList())
def test_5(self): """ added node is now head """ dl = DoubleLinkedList() n1 = Node(5) n2 = Node(3) dl.push(n1) dl.push(n2) self.assertEqual(dl.head._value, 3)
def test_6(self): """ prev of prior head is now node 2 (n1 here) """ dl = DoubleLinkedList() n1 = Node(5) n2 = Node(3) dl.push(n1) dl.push(n2) self.assertEqual(n1._prev._value, 3)
def test_3(self): """ test append by tail """ dl = DoubleLinkedList() n1 = Node(5) n2 = Node(3) dl.append(n1) dl.append(n2) self.assertEqual(dl.tail._value, 3)
def test_2(self): """ test append by head """ dl = DoubleLinkedList() n1 = Node(5) n2 = Node(3) dl.append(n1) dl.append(n2) self.assertEqual(dl.head._next._value, 3)
def test_10(self): """ remove by value, return an exception if doesn't exist """ dl = DoubleLinkedList() n1 = Node(5) n2 = Node(3) n3 = Node(6) dl.append(n1) dl.append(n2) dl.append(n3) dl.remove(7) self.assertEqual(dl.remove(7), "Node does not exist!")
def find_components(g: Graph): """ Breadth First Search Alg. Which also: tests if the graph is connected, computes the distance from s to the other edges labels the vertices in the order they are visited :param g: Graph :return: (isConnected, {dict of components}) """ visited = set() components = dict() count = 1 while len(visited) < len(g.vertices): for o in g.vertices: if o not in visited: v = o break queue = DoubleLinkedList() # queue queue.append(v) visited.add(v) components[count] = [v] while len(queue) > 0: w = queue.pop() # BFS so FIFO for n in w.neighbours: # If w not visited if n not in visited: visited.add(n) queue.append(n) components[count].append(n) count += 1 is_connected = len(components) == 1 return is_connected, components
def test_9(self): """ remove by value, removed node's next now next of removed node's prev """ dl = DoubleLinkedList() n1 = Node(5) n2 = Node(3) n3 = Node(6) dl.append(n1) dl.append(n2) dl.append(n3) dl.remove(3) self.assertEqual(dl.head._next._value, 6)
def test_7(self): """check that shift removes last node""" n1 = Node('A') n2 = Node('B') n3 = Node('C') dl = DoubleLinkedList() dl.append(n1) dl.append(n2) dl.append(n3) dl.shift() self.assertEqual(dl.tail._value, 'B')
def test_6(self): """check that pop removes head""" n1 = Node('A') n2 = Node('B') dl = DoubleLinkedList() dl.append(n1) #head and tail at this point dl.append(n2) # A is head and B is now tail dl.pop() # removes A so head value should be B self.assertEqual(dl.head._value, 'B')
def test_8(self): """ prev of prior tail is now tail """ dl = DoubleLinkedList() n1 = Node(5) n2 = Node(3) dl.push(n1) dl.push(n2) dl.shift() self.assertEqual(dl.tail._value, 3)
def test_7(self): """ next of prior head is now head """ dl = DoubleLinkedList() n1 = Node(5) n2 = Node(3) dl.push(n1) dl.push(n2) dl.pop() self.assertEqual(dl.head._value, 5)
def test_5(self): """check that push adds to front""" n1 = Node('A') n2 = Node('B') dl = DoubleLinkedList() dl.append(n1) dl.append(n2) n3 = Node('C') #will push C to front(head) dl.push(n3) self.assertEqual(dl.head._value, 'C')
class Deque(object): """Will create a instance of Deque.""" def __init__(self, iterable=None): """Will init a new instance of the Stack class.""" from dll import DoubleLinkedList self._dll = DoubleLinkedList() self._counter = 0 def append(self, data): """Will push a new element into the Deque.""" self._dll.append(data) self._counter += 1 def pop_left(self): """Will remove the head value.""" if self._dll.head: self._counter -= 1 else: raise ValueError('no value left to pop') return self._dll.pop() def append_left(self, data): """Append a value to the head.""" self._dll.push(data) self._counter += 1 def pop(self): """Pop a value from the end.""" if self._dll.tail: self._counter -= 1 else: raise ValueError('no value left to pop') return self._dll.shift() def peek_left(self): """Will return the value that pop_left would return.""" if self._dll.head: return self._dll.head.data else: raise ValueError('no value in the deque to peek') def peek(self): """Will return the value that pop would return.""" if self._dll.head: return self._dll.tail.data else: raise ValueError('no value in the deof correct typeque to peek') def size(self): """Return the size of the deque.""" return self._counter def __len__(self): """Will return the length of the deque using len().""" return self._counter
def test_8(self): """test to remove tail by using remove method""" n1 = Node('A') n2 = Node('B') n3 = Node('C') dl = DoubleLinkedList() dl.append(n1) dl.append(n2) dl.append(n3) dl.remove('C') #this removes C so tail should become BaseException self.assertEqual(dl.tail._value, 'B')
def set(self, vertex: Vertex, color: int): """ Adds the given vertex to the given color class Add the given vertex to the color class. If the color class does not yet exist, a new color class is created to which the vertex is added. :param color: the name of the color class :param vertex: the `Vertex` to add to the color class :raises KeyError when vertex already belongs to the coloring """ if vertex in self._vertex_dict: raise KeyError('Vertex {} already in coloring, color: {}. ' 'Use recolor instead'.format( str(vertex), str(self.color(vertex)))) self._dict.setdefault(color, DoubleLinkedList()).append(vertex) self._vertex_dict[vertex] = color
class Deque(object): """Deque data structure, can add and remove from both ends.""" def __init__(self): """Initialize the deque.""" self.deque = DoubleLinkedList() def append(self, value): """Add an item to the back of the deque.""" self.deque.append(value) def append_left(self, value): """Add an item to the front of the deque.""" self.deque.push(value) def pop(self): """Pop a value off of the back of the deque and return it.""" return self.deque.shift() def pop_left(self): """Pop a value off of the front of the deque and return it.""" return self.deque.pop() def peek(self): """Return the next value that would be poped at the end of deque.""" try: return self.deque.tail.data except AttributeError: return None def peek_left(self): """Return the next value to pop in the deque.""" try: return self.deque.head.data except AttributeError: return None def size(self): """Return the number of nodes in the deque.""" return self.deque.__len__()
class Dictionary(object): def __init__(self, num_buckets=256): """Initializes a Map with the given number of buckets.""" # the map is a DLL self.map = DoubleLinkedList() # we add a DLL for every bucket so now we have # a big DLL containing other tiny DLLs - containers # for the key -value tuples 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 Map's buckets.""" # returns the modulus of hash number of the key # and the number of items in the map return hash(key) % self.map.count() def get_bucket(self, key): """Given a key, find the bucket where it would go.""" # set the bucket_id to the hash value of the key bucket_id = self.hash_key(key) # get the bucket_id and return it return self.map.get(bucket_id) def get_slot(self, key, default=None): """Return either the bucket and node for a slot, or None, None""" # set bucket to the bucket_id bucket = self.get_bucket(key) # if there's a bucket # set node to bucket.begin if bucket: node = bucket.begin i = 0 # while there is a node while node: # return the bucket and the node # if the key = node.value[0] if key == node.value[0]: return bucket, node # else set the node to node.next 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 __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): """Init for Queue.""" self._new_dll = DoubleLinkedList()
def __init__(self): """Initialize the deque.""" self.deque = DoubleLinkedList()
def random_list(count): numbers = DoubleLinkedList() for i in range(count, 0, -1): numbers.shift(randint(0, 10000)) return numbers
def dll(): """Instantiate a dll for testing.""" from dll import DoubleLinkedList double_link = DoubleLinkedList() return double_link
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): """Return 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