def __init__(self): DLL.__init__(self) # Meaningful aliases for push and pop # for stack operations self.push = self.push_front self.pop = self.pop_front
def test_remove_first_instance_of_value_from_doubly_linked_list(itr): """Test that removing any node from any length list adjusts the list.""" from dll import DLL l = DLL(itr) l.remove(1) assert l.head.val == 0 assert l.head.nxt.val == 0 assert l.head.nxt.nxt.val == 1 assert l.length == len(itr) - 1
def test_remove_head_of_doubly_linked_list(itr): """Test that removing the head from any length list moves the head.""" from dll import DLL l = DLL(itr) l.remove(itr[-1]) assert l.head.val == itr[-2] assert l.length == len(itr) - 1 assert l.tail.val == itr[0] assert l.head.prev is None
def test_remove_tail_from_doubly_linked_list(itr): """Test that removing tail from any length list adjusts the list.""" from dll import DLL l = DLL(itr) l.remove(itr[0]) assert l.tail.val == itr[1] assert l.tail.nxt is None assert l.length == len(itr) - 1
def test_shift_one_item_from_any_length_doubly_linked_list(itr): """Test that shift item removes head from DLL.""" from dll import DLL l = DLL(itr) x = l.shift() assert x == itr[0] assert l.head.val == itr[-1] assert l.tail.val == itr[1] assert l.tail.nxt is None assert l.length == len(itr) - 1
def test_pop_one_item_from_any_length_doubly_linked_list(itr): """Test that pop item removes head from DLL.""" from dll import DLL l = DLL(itr) x = l.pop() assert x == itr[-1] assert l.head.val == itr[-2] assert l.head.prev is None assert l.tail.val == itr[0] assert l.length == len(itr) - 1
def __init__(self, id, load_function, MAX_SIZE, TIMEOUT): ''' params: id: unique identifier load_function: if there's a cache miss, use this function to load the value associated with a given key MAX_SIZE: int, maximum number of items the ServerNode can hold TIMEOUT: int/float, seconds until a node times out from unuse ''' self.id = id self.load_function = load_function self.nodes = DLL(MAX_SIZE, TIMEOUT)
def test_shift_multiple_items_from_any_length_doubly_linked_list(itr): """Test that shift items removes head from DLL.""" from dll import DLL from random import randint l = DLL(itr) num = randint(2, len(itr) - 1) for _ in range(num): x = l.shift() assert x == itr[num - 1] assert l.head.val == itr[-1] assert l.tail.val == itr[num] assert l.tail.nxt is None assert l.length == len(itr) - num
def parenthetics(string): """The parenthetics module checks for open, broken, or balanced sets.""" matches = DLL() for char in string: if char == "(": matches.append(char) if char == ")": if matches.head is None or matches.pop() != "(": return -1 if matches.head is None: return 0 else: return 1
def test_search(self): dll = DLL() # Test an empty Linked List assert dll.search(5) == 'Linked List is empty.' # Test Linked List with some nodes dll.addNode(1) dll.addNode(2) dll.addNode(3) assert dll.search('python') == False assert dll.search(3) == True
def test_dll(fin): for cmd in fin: cmd = cmd.strip().split() if cmd[0] == "new": dll = DLL() test_print(dll) elif cmd[0] == "insert": test_insert(dll, int(cmd[1])) elif cmd[0] == "remove": test_remove(dll) elif cmd[0] == "move_to_next": test_move_to_next(dll) elif cmd[0] == "move_to_prev": test_move_to_prev(dll) elif cmd[0] == "move_to_pos": test_move_to_pos(dll, int(cmd[1])) elif cmd[0] == "get_first_node": test_get_first_node(dll) elif cmd[0] == "get_last_node": test_get_last_node(dll) elif cmd[0] == "clear": test_clear(dll) elif cmd[0] == "sort": test_sort(dll) elif cmd[0] == "partition": test_partition(dll)
def test_doubly_linked_list_constructor_with_iterable(itr): """Test that a DLL created with an iterable contains all items.""" from dll import DLL l = DLL(itr) assert l.head.val == itr[-1] assert l.tail.val == itr[0] assert l.length == len(itr)
class Deque(object): """Python Implementation of Deque Data Structure""" def __init__(self, iter=None): """Constructor Function for Deque.""" self.container = DLL() if iter: for val in iter: self.container.append(val) def append(self, val): """Add val to the end of the Deque.""" self.container.append(val) def appendleft(self, val): """Add val to the start of the Deque.""" self.container.insert(val) def pop(self): """Remove and return the value at the end of the Deque.""" rtn_val = self.container.shift() if rtn_val is not None: return rtn_val raise AttributeError def popleft(self): """Remove and the return the value at the front of the Deque.""" rtn_val = self.container.pop() if rtn_val is not None: return rtn_val raise AttributeError def peek(self): """Return the next value that would be popped.""" try: return self.container.tail.val except AttributeError: return None def peekleft(self): """Return the next value that would popleft.""" try: return self.container.head.val except AttributeError: return None def size(self): """Return the size of the Deque.""" return self.container.size()
def test_size(self): dll = DLL() size = dll.size() # Test an empty Linked List assert size == 0 # Test Linked List with some nodes dll.addNode(1) dll.addNode(2) dll.addNode(3) size = dll.size() assert size == 3
class ProperTarget(unittest.TestCase): """This handles the case where the file is a proper dll. """ def setUp(self): self.myDll = DLL(goodDataSource) def testGetMemorySize(self): """ProperTarget::getMemorySize()""" assertEquals('Memory size: ', self.myDll.getMemorySize(), 8192) def testGetRoundedMemorySize(self): """ProperTarget::getRoundedMemorySize()""" assertEquals('Rounded size: ', self.myDll.getRoundedMemorySize(), 65536) def testGetBaseAddress(self): """ProperTarget::getBaseAddress()""" assertEquals('Base address: ', '%x' % self.myDll.getBaseAddress(), '73dc0000')
class ImproperTarget(unittest.TestCase): """This handles the case where the filename provided to DLL is not a dll. All queries against a non-dll should return 0. """ def setUp(self): self.myDll = DLL(badDataSource) def testGetMemorySize(self): """ImproperTarget::getMemorySize()""" assertEquals('Memory size: ', self.myDll.getMemorySize(), 0) def testGetRoundedMemorySize(self): """ImproperTarget::getRoundedMemorySize()""" assertEquals('Rounded memory size: ', self.myDll.getRoundedMemorySize(), 0) def testGetBaseAddress(self): """ProperTarget::getBaseAddress()""" assertEquals('Base address: ', self.myDll.getBaseAddress(), 0)
class Queue(object): """Structure for values in a queue where first item in is first out.""" def __init__(self, iterable=None): """Construct a new queue.""" self._values = DLL(iterable) @property def front(self): """Get the node at front of the queue.""" return self._values.tail @property def back(self): """Get the node at back of the queue.""" return self._values.head def __len__(self): """Overwrite the default return for len function.""" return len(self._values) def size(self): """Get the size of the queue.""" return len(self) def enqueue(self, val): """Add a value to the end of the queue.""" self._values.push(val) def dequeue(self): """Remove the value from the front of the queue and return it.""" try: return self._values.shift() except IndexError: raise IndexError('Cannot dequeue from empty queue.') def peek(self): """Get the value from the front of the queue without removing it.""" if self.front: return self.front.val return None
class Queue(object): """Queue class that contains a DLL.""" def __init__(self, iter=None): self._container = DLL() if iter: for val in iter: self._container.append(val) def enqueue(self, val): """Adds a value to the end of the queue.""" self._container.append(val) def dequeue(self): """Removes and returns value from front of queue.""" temp_value = self._container.pop() if temp_value is not None: return temp_value raise ValueError def peek(self): """Returns the next value in the queue without dequeing it.""" try: return self._container.head.val except AttributeError: return None def size(self): """Returns the size of the queue.""" return self._container.size()
def test_remove(test_empty_DLL, test_DLL): with pytest.raises(ValueError): test_empty_DLL.remove(3) test_DLL.remove(2) assert test_DLL.to_string() == '(3, 1)' test_DLL.remove(3) assert test_DLL.to_string() == '(1)' test_DLL.remove(1) assert test_DLL.to_string() == '()' long_DLL = DLL([5, 5, 6, 7, 4, 6, 0]) long_DLL.remove(5) assert long_DLL.to_string() == '(0, 6, 4, 7, 6, 5)' long_DLL.remove(6) assert long_DLL.to_string() == '(0, 4, 7, 6, 5)'
def stringShiftDriver(str, offset): strTarget = "" if len(str) == 0 or offset == 0: return str for i in range(len(str)): try: if (ord(str[i]) > 255): continue if str[i].isalpha(): # ALPHA if str[i].isupper(): #UP strTarget += DLL.find(alphaList.head, str[i].lower(), offset, ofAlpha).upper() elif str[i].islower(): #LOW strTarget += DLL.find(alphaList.head, str[i], offset, ofAlpha) elif str[i].isnumeric(): # NUM strTarget += DLL.find(digitList.head, str[i], offset, ofDigit) else: # ALL OTHERS strTarget += str[i] continue except: print("usage: utf-8") continue return strTarget
class ProperTarget( unittest.TestCase ): """This handles the case where the file is a proper dll. """ def setUp( self ): self.myDll = DLL( goodDataSource ) def testGetMemorySize( self ): """ProperTarget::getMemorySize()""" assertEquals( 'Memory size: ' , self.myDll.getMemorySize(), 8192 ) def testGetRoundedMemorySize( self ): """ProperTarget::getRoundedMemorySize()""" assertEquals( 'Rounded size: ' , self.myDll.getRoundedMemorySize(), 65536 ) def testGetBaseAddress( self ): """ProperTarget::getBaseAddress()""" assertEquals( 'Base address: ', '%x' % self.myDll.getBaseAddress(), '73dc0000' )
def test_addNode(self): dll = DLL() dll.head dll.addNode(1) assert str(dll.head) == 'DLLNode object: data=1' assert dll.head.previous == None assert dll.head.next == None dll.addNode(2) assert str(dll.head) == 'DLLNode object: data=2' assert dll.head.previous == None assert str(dll.head.next) == 'DLLNode object: data=1' assert dll.size() == 2 assert dll.head.next.next == None
class Deque(object): """Structure for values in a deque, a double-ended queue.""" def __init__(self, iterable=None): """Construct a ne deque.""" self._values = DLL(iterable) @property def front(self): """Get the node at front of the deque.""" return self._values.tail @property def end(self): """Get the node at end of the deque.""" return self._values.head def __len__(self): """Overwrite the default return for len function.""" return len(self._values) def append(self, val): """Add a value to the end of the deque.""" self._values.push(val) def appendleft(self, val): """Add a value to the front of the deque.""" self._values.append(val) def pop(self): """Remove the value from the end of the deque and return it.""" try: return self._values.pop() except IndexError: raise IndexError('Cannot pop from empty deque.') def popleft(self): """Remove the value from the front of the deque and return it.""" try: return self._values.shift() except IndexError: raise IndexError('Cannot popleft from empty deque.') def peek(self): """Get the value from the end of the deque without removing it.""" if self.end: return self.end.val def peekleft(self): """Get the value from the front of the deque without removing it.""" if self.front: return self.front.val def size(self): """Get the size of the deque.""" return len(self)
class ImproperTarget(unittest.TestCase): """This handles the case where the filename provided to DLL is not a dll. All queries against a non-dll should return 0. """ def setUp(self): self.myDll = DLL( badDataSource ) def testGetMemorySize( self ): """ImproperTarget::getMemorySize()""" assertEquals( 'Memory size: ', self.myDll.getMemorySize(), 0 ) def testGetRoundedMemorySize( self ): """ImproperTarget::getRoundedMemorySize()""" assertEquals( 'Rounded memory size: ', self.myDll.getRoundedMemorySize(), 0 ) def testGetBaseAddress( self ): """ProperTarget::getBaseAddress()""" assertEquals( 'Base address: ', self.myDll.getBaseAddress(), 0 )
class ServerNode(): def __init__(self, id, load_function, MAX_SIZE, TIMEOUT): ''' params: id: unique identifier load_function: if there's a cache miss, use this function to load the value associated with a given key MAX_SIZE: int, maximum number of items the ServerNode can hold TIMEOUT: int/float, seconds until a node times out from unuse ''' self.id = id self.load_function = load_function self.nodes = DLL(MAX_SIZE, TIMEOUT) def get_state(self): ''' returns: list of current nodes ''' nodes = [] for node in self.nodes: nodes.append(node) return nodes def get(self, key): ''' returns: value associated with given key If a key is not found, load the data into the cache and return. ''' result = self.nodes.get(key) if result is None: value = self.load_function(key) self.nodes.add(key, value) return value else: return result
def test_remove_random_inner_node_from_doubly_linked_list(itr): """Test that removing any node from any length list adjusts the list.""" from dll import DLL from random import choice l = DLL(itr) remove_item = choice(itr[1:-1]) l.remove(remove_item) with pytest.raises(ValueError): l.remove(remove_item) assert l.length == len(itr) - 1
def test_dll(fin): for cmd in fin: cmd = cmd.strip().split() if cmd[0] == "new": dll = DLL() test_print(dll) elif cmd[0] == "insert": test_insert(dll, int(cmd[1])) elif cmd[0] == "remove": test_remove(dll) elif cmd[0] == "move_to_next": test_move_to_next(dll) elif cmd[0] == "move_to_prev": test_move_to_prev(dll) elif cmd[0] == "move_to_pos": test_move_to_pos(dll, int(cmd[1])) elif cmd[0] == "remove_all": test_remove_all(dll, int(cmd[1])) elif cmd[0] == "sort": test_sort(dll) elif cmd[0] == "reverse": test_reverse(dll)
def findPairsWithSumX(head, tail, x): result = [] if head is None or tail is None: return result while head != tail and tail.next != head: if head.data + tail.data == x: result.append((head.data, tail.data) head, tail = head.next, tail.prev elif head.data + tail.data < x: head = head.next else: tail = tail.prev return result s = [1, 2, 4, 5, 6, 8, 9] dll = DLL() for i in s: dll.append(i) dll.printList() print findPairsWithSumX(dll.head, dll.tail, 7)
while current and current.next: if current.next.data > newNode.data: break current = current.next if current is None: dll.head = newNode elif current.next is None: current.next = newNode newNode.prev = current dll.tail = newNode else: newNode.next = current.next newNode.prev = current newNode.next.prev = newNode current.next = newNode dll = DLL() for i in range(7): dll.append(2 * i + 1) dll.printList() sortedInsert(dll, 0) dll.printList() sortedInsert(dll, 4) dll.printList() sortedInsert(dll, 16) dll.printList() sortedInsert(dll, 0) dll.printList() sortedInsert(dll, 7) dll.printList()
dll.head = None dll.tail = None return if k == 1: node = dll.head dll.head = node.next node.next = None dll.head.prev = None else: current = dll.head while current and k > 1: current = current.next k -= 1 if current is None: return elif current.next is None: dll.tail = current current.prev.next = None current.prev = None else: current.prev.next = current.next current.next.prev = current.prev dll = DLL() for i in range(8): dll.append(i) dll.printList() deleteAt(dll, 8) print dll.tail dll.printList()
def setUp(self): self.myDll = DLL( badDataSource )
def setUp(self): self.myDll = DLL(badDataSource)
def __init__(self, iter=None): """Constructor Function for Deque.""" self.container = DLL() if iter: for val in iter: self.container.append(val)
def __init__(self, iter=None): self._container = DLL() if iter: for val in iter: self._container.append(val)
def test_shift_single(): test_DLL = DLL([1]) assert test_DLL.shift() == 1 assert test_DLL.shift() is None
def setUp(self): self.dll = DLL()
def test_pop_single(): test_DLL = DLL([1]) assert test_DLL.pop() == 1 assert test_DLL.pop() is None