class LinkedQueue(Queue):
def __init__(self):
self.list = DoublyLinkedList()
self.iter_list = iter(self.list)
def size(self):
return self.list.size()
def is_empty(self):
return self.size() == 0
def peek(self):
if self.isEmpty():
raise Exception('Queue Empty')
return self.list.peek_first()
def poll(self):
''' poll from front of queue '''
if self.isEmpty():
raise Exception('Queue Empty')
return self.list.remove_head()
def offer(self, elem):
''' add elem to back of queue '''
self.list.append(elem)
def __iter__(self):
''' called when iteration is initialized '''
self.iter_list = iter(self.list)
return self
def __next__(self):
''' To move to next element '''
return next(self.iter_list)
def test_add_before_node(self):
llist = DoublyLinkedList()
llist.append('A')
llist.append('B')
llist.append('D')
llist.add_before_node('D', 'C')
self.assertEqual(repr(llist), 'A, B, C, D')
def test_dll():
test_dll = Dll()
test_dll.insert('test1')
test_dll.insert('test2')
test_dll.append('test3')
return test_dll
class Heap:
def __init__(self):
self.storage = DoublyLinkedList()
def insert(self, value):
self.storage.append(value)
self._bubble_up(len(self.storage) - 1)
def delete(self):
value = self.storage[0]
if len(self.storage) > 1:
self.storage[0] = self.storage.remove_from_tail()
elif len(self.storage) == 1:
self.storage.remove_from_tail()
self._sift_down(0)
return value
def get_max(self):
return self.storage[0]
def __len__(self):
return len(self.storage)
get_size = __len__
def _swap(self, index_0, index_1):
(
self.storage[index_0],
self.storage[index_1],
) = (
self.storage[index_1],
self.storage[index_0],
)
def _bubble_up(self, index):
parent_index = (index - 1) // 2
if parent_index < 0:
return
# print(f'_bubble_up({index})')
# print(self.storage)
# print(f'index {index}: {self.storage[index]}')
# print(f'parent_index {parent_index}: {self.storage[parent_index]}')
if self.storage[index] > self.storage[parent_index]:
self._swap(index, parent_index)
self._bubble_up(parent_index)
def _sift_down(self, index):
child_values = list(self.storage[index * 2 + 1:index * 2 + 3])
if len(child_values) == 0:
return
if self.storage[index] > max(child_values):
return
if len(child_values) == 1:
self._swap(index * 2 + 1, index)
elif child_values[0] >= child_values[1]:
self._swap(index * 2 + 1, index)
self._sift_down(index * 2 + 1)
else:
self._swap(index * 2 + 2, index)
self._sift_down(index * 2 + 2)
class Queue(object):
"""Class to create instance of Queue."""
def __init__(self):
"""Create new instance of Queue class object."""
self.queue = DoublyLinkedList()
self.is_empty = True
def enqueue(self, data):
"""Method to add given data to Queue class object."""
if not self.queue.head:
self.is_empty = False
self.queue.append(data)
def dequeue(self):
"""Method to remove and return item at front of Queue class object."""
if not self.queue.head:
raise IndexError('Cannot perform dequeue on empty Queue.')
if not self.queue.head.next_node:
self.is_empty = True
return self.queue.pop()
def peek_front(self):
"""Method to return item at front of Queue class object."""
return self.queue.head
def peek_back(self):
"""Method to return item at back of Queue class object."""
return self.queue.tail
def test_append_method_assigns_head_and_tail_to_be_same_node_if_list_empty():
"""Test that the append method of the DoublyLinkedList class correctly
assigns the list's head and tail to be the same Node if append is used on
an empty list."""
dll = DoublyLinkedList()
dll.append(1)
assert dll.tail is dll.head
def test_append_method_creates_instance_of_node_class_as_new_node():
"""Test that the append method of the DoublyLinkedList class adds an
instance of the Node class as the new Node in the list."""
dll = DoublyLinkedList()
dll.add_node(1)
dll.append(2)
assert isinstance(dll.tail, Node)
def test_append_method_correctly_reassigns_tail_to_newly_added_node():
"""Test that the append method of the DoublyLinkedList class correctly
reassigns the list's tail to become the newly appended Node."""
dll = DoublyLinkedList()
dll.add_node(1)
old_tail = dll.tail
dll.append(2)
assert dll.tail != old_tail and dll.tail.data != old_tail.data
def test_append_method_assigns_new_tails_prev_node_to_be_old_tail():
"""Test that the append method of the DoublyLinkedList class assigns the
new tail's prev_node pointer to be the old tail, preserving the integrity
of the list."""
dll = DoublyLinkedList()
dll.add_node(10)
old_tail = dll.tail
dll.append(20)
assert dll.tail.prev_node is old_tail
def test_append_method_correctly_reassigns_tail_through_multiple_uses():
"""Test that the append method of the DoublyLinkedList class correctly
reassigns the list's tail after multiple uses."""
dll = DoublyLinkedList()
dll.append(3)
old_tail = dll.tail
dll.append(6)
dll.append(9)
assert dll.tail is not old_tail
def test_append_method_does_not_reassign_head_through_multiple_uses():
"""Test that the append method of the DoublyLinkedList class doesn't
reassign the list's head after first use, even after multiple uses."""
dll = DoublyLinkedList()
dll.append(5)
head = dll.head
dll.append(10)
dll.append(15)
assert dll.head is head
def test_doubly_linked_list_search(self):
doubly_linked_list = DoublyLinkedList()
doubly_linked_list.append(25)
pos = doubly_linked_list.search(25)
self.assertIsNotNone(doubly_linked_list)
self.assertTrue(pos == 0)
doubly_linked_list.append("Riccardo")
pos = doubly_linked_list.search("Riccardo")
self.assertEqual(pos,1)
doubly_linked_list.insert_head("Prova")
pos = doubly_linked_list.search("Prova")
self.assertTrue(pos == 0)
class Deque(object):
"""Deque object class."""
def __init__(self):
"""Init new deque instance."""
self._deque = DoublyLinkedList()
def append(self, val):
"""Add item to right end of deque."""
self._deque.append(val)
def appendleft(self, val):
"""Add item to left end of deque."""
self._deque.push(val)
def pop(self):
"""Remove item from right end of deque."""
try:
return self._deque.shift()
except IndexError:
raise IndexError('Cannot pop from empty deque.')
def popleft(self):
"""Remove item from head, left-side, of deque."""
try:
return self._deque.pop()
except IndexError:
raise IndexError('Cannot pop from empty deque')
def peek(self):
"""Show data of item at back of deque."""
try:
return self._deque.tail.data
except AttributeError:
return None
def peekleft(self):
"""Show data of item at front of deque."""
try:
return self._deque.head.data
except AttributeError:
return None
def size(self):
"""Return the size of the deque."""
return self._deque._len
def __len__(self):
"""Return the size of the deque with len."""
return len(self._deque)
class Stack:
def __init__(self):
self.size = 0
# Why is our DLL a good choice to store our elements?
self.storage = DoublyLinkedList()
def push(self, value):
self.storage.append(value)
def pop(self):
return self.storage.pop()
def len(self):
return len(self.storage)
def test_DoublyLinkedList_append(self):
l1 = DoublyLinkedList()
l1.append(0)
# ensure Node(0) added to list
Node0 = l1.head
self.assertIsNotNone(l1.head)
self.assertIsNotNone(l1.tail)
self.assertEqual(Node0.val, 0)
self.assertIsNone(Node0.link)
# ensure Node(1) appended to back of list
l1.append(1)
Node0 = l1.head
self.assertEqual(Node0.val, 0)
self.assertIsNotNone(Node0.link)
# ensure Node(0) is next in list
Node1 = Node0.link
self.assertEqual(Node1.val, 1)
self.assertIsNone(Node1.link)
# ensure adding 'None' adds something
sz1 = l1.size()
l1.append(None)
self.assertEqual(sz1+1, l1.size())
# ensure adding recursively adds nothing
sz1 = l1.size()
l1.append(l1)
self.assertEqual(sz1, l1.size())
class Deque(object):
"""Create a Deque object."""
def __init__(self):
"""Initialize Deque using DoublyLinkedList methods."""
self._doubly_linked_list = DoublyLinkedList()
def append(self, val):
"""Add a node to back Deque."""
self._doubly_linked_list.append(val)
def appendleft(self, val):
"""Add a node to front Deque."""
self._doubly_linked_list.push(val)
def pop(self):
"""Remove node at the back."""
try:
return self._doubly_linked_list.shift()
except IndexError:
raise IndexError('Nothing to pop from back')
def popleft(self):
"""Remove node at the front."""
try:
return self._doubly_linked_list.pop()
except IndexError:
raise IndexError('Nothing to pop from front')
def peek(self):
"""Get value of next node to be popped left."""
if self._doubly_linked_list.size() == 0:
return None
return self._doubly_linked_list.tail.data
def peekleft(self):
"""Get value of next node to be popped."""
if self._doubly_linked_list.size() == 0:
return None
return self._doubly_linked_list.head.data
def size(self):
"""Get the size of the Deque."""
return self._doubly_linked_list.size()
def __len__(self):
"""Return the length of the Deque using Python len function."""
return self.size()
def test_delete_node(self):
llist = DoublyLinkedList()
llist.append('A')
llist.append('B')
llist.append('C')
llist.append('D')
llist.delete('C')
self.assertEqual(repr(llist), 'A, B, D')
# delete first node
llist.delete('A')
self.assertEqual(repr(llist), 'B, D')
# delete last node
llist.delete('D')
self.assertEqual(repr(llist), 'B')
# delete only node
llist.delete('B')
class RingBuffer: def __init__(self, capacity): self.capacity = capacity self.current = None self.storage = DoublyLinkedList() def append(self, item): if len(self.storage) < self.capacity: self.storage.append(item) self.current = len(self.storage) - 1 return self.current += 1 if self.current >= self.capacity: self.current = 0 self.storage[self.current] = item def get(self): return list(self.storage)
def run(self, input_string):
time1 = time.time()
# convert the input to a doubly linked list
band = DoublyLinkedList()
for letter in input_string:
band.append(letter)
tm_is_running = True
while (tm_is_running):
#print("current_bit ", band.get(self.current_bit))
#print("current_state ", self.current_state)
#print()
# main loop
for delta in self.delta_funcs:
#print("delta ", delta)
# find the delta function for the current symbol and current state
if delta[0][0] == self.current_state and delta[0][1] == band.get(self.current_bit):
# set the new state
self.current_state = delta[1][0]
# set the new symbol
band.replace(self.current_bit, delta[1][1])
direction = delta[1][2]
if direction == "R":
self.current_bit += 1
if band.get(self.current_bit + 1) == None:
band.append(" ")
if direction == "L":
band.push(" ")
self.current_bit = 0
break
# check if the current state is the accepting state
if (self.current_state == self.accepting_state):
tm_is_running = False
time2 = time.time()
print('accepted in %0.3f ms' % ((time2-time1) * 1000.0))
return
def test_doubly_linked_list_remove_end(N):
print("Testing DoublyLinkedList")
l = DoublyLinkedList()
print(f"Appending {int(N)} values")
[l.append(i) for i in range(int(N))]
print(f"Removing {int(N)-10} values from the end")
[l.remove_end() for i in range(int(N) - 10)]
try:
l.remove_end()
except Exception:
print("Got expected Exception")
class Deque(object):
"""Deque data structure, can add and remove from both ends."""
def __init__(self):
"""Initialize the deque."""
self.deque = DoublyLinkedList()
def append(self, value):
"""Add an item to the back of the deque."""
self.deque.append(value)
def appendleft(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 popleft(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 peekleft(self):
"""Return the next value in the deque. This is the value that popleft would remove."""
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__()
def test_doubly_linked_list_insert(self):
doubly_linked_list = DoublyLinkedList()
with self.assertRaises(ValueError):
doubly_linked_list.insert(99, 5)
print doubly_linked_list.append(25)
print doubly_linked_list.append("Riccardo")
print doubly_linked_list.append("Try")
print doubly_linked_list.insert(6, 3)
self.assertTrue(doubly_linked_list.tail.previous.item == "Try")
self.assertEqual(doubly_linked_list.tail.next, None)
self.assertTrue(doubly_linked_list.tail.item == 6)
def test_doubly_linked_list_append(self):
doubly_linked_list = DoublyLinkedList()
doubly_linked_list.append(25)
self.assertIsNotNone(doubly_linked_list)
self.assertTrue(doubly_linked_list.__len__() == 1)
doubly_linked_list.append("Riccardo")
self.assertTrue(doubly_linked_list.__len__() == 2)
self.assertTrue(doubly_linked_list.head.item == 25)
self.assertTrue(doubly_linked_list.tail.item == "Riccardo")
self.assertEqual(doubly_linked_list.tail.next, None)
self.assertTrue(doubly_linked_list.head.next.item == "Riccardo")
self.assertFalse(doubly_linked_list.head.next.item == "25")
doubly_linked_list.append("Try")
self.assertTrue(doubly_linked_list.head.item == 25)
self.assertTrue(doubly_linked_list.head.next.item == "Riccardo")
self.assertTrue(doubly_linked_list.tail.item == "Try")
self.assertTrue(doubly_linked_list.head.next.item == "Riccardo")
self.assertEqual(doubly_linked_list.tail.next, None)
def test_doubly_linked_list_delete(self):
doubly_linked_list = DoublyLinkedList()
doubly_linked_list.append(25)
doubly_linked_list.append("Riccardo")
doubly_linked_list.append("Try")
doubly_linked_list.insert(6, 3)
self.assertIsNotNone(doubly_linked_list)
self.assertTrue(doubly_linked_list.__len__() == 4)
self.assertTrue(doubly_linked_list.tail.item == 6)
doubly_linked_list.delete(3)
self.assertTrue(doubly_linked_list.__len__() == 3)
self.assertTrue(doubly_linked_list.tail.item == "Try")
self.assertFalse(doubly_linked_list.tail.item == 6)
self.assertTrue(doubly_linked_list.head.item == 25)
self.assertFalse(doubly_linked_list.head.next.item == "Try")
self.assertTrue(doubly_linked_list.head.next.item == "Riccardo")
doubly_linked_list.delete(0)
self.assertTrue(doubly_linked_list.head.item == "Riccardo")
self.assertTrue(doubly_linked_list.head.next.item == "Try")
def singly_palindrom(slist):
head = slist.head
vals = ""
while head:
vals += str(head.data)
head = head.next
if len(longestPalindrome(vals)) == len(vals):
return True
return False
if __name__ == "__main__":
#__________FOR DOUBLY LINKED LIST_______________
dlist = DoublyLinkedList()
dlist.append(1)
dlist.append(2)
dlist.append(3)
dlist.append(2)
dlist.append(1)
assert doubly_palindrom(dlist) == True
dlist = DoublyLinkedList()
dlist.append(1)
dlist.append(4)
assert doubly_palindrom(dlist) == False
#__________FOR SINGLY LINKED LIST_______________
slist = LinkedList()
slist.append(1)
slist.append(2)
def get_instance():
linked_list = DoublyLinkedList(Node(100))
linked_list.append(Node(200))
linked_list.append(Node(300))
linked_list.append(Node(400))
return linked_list
def test_doubly_linked_list_append(N):
print("Testing DoublyLinkedList")
l = DoublyLinkedList()
print(f"Appending {int(N)} values")
[l.append(i) for i in range(int(N))]
class TestDoublyLinkedList(unittest.TestCase): def setUp(self): self.emptyList = DoublyLinkedList() self.oneItemList = DoublyLinkedList() self.twoItemList = DoublyLinkedList() self.fiveItemList = DoublyLinkedList() self.one = [3] self.two = [2, 9] self.five = [6, 1, 0, 5, 8] for i in self.one: self.oneItemList.append(i) for i in self.two: self.twoItemList.append(i) for i in self.five: self.fiveItemList.append(i) def testEmptyAppend(self): self.emptyList.append(4) self.assertEqual(self.emptyList.getPosition(0), 4) def testOneAppend(self): self.oneItemList.append(1) self.assertEqual(self.oneItemList.getPosition(0), 3) self.assertEqual(self.oneItemList.getPosition(1), 1) def testTwoAppend(self): self.twoItemList.append(6) self.assertEqual(self.twoItemList.getPosition(0), 2) self.assertEqual(self.twoItemList.getPosition(1), 9) self.assertEqual(self.twoItemList.getPosition(2), 6) def testEmptyPrepend(self): self.emptyList.prepend(4) self.assertEqual(self.emptyList.getPosition(0), 4) def testOnePrepend(self): self.oneItemList.prepend(1) self.assertEqual(self.oneItemList.getPosition(0), 1) def testTwoPrepend(self): self.twoItemList.prepend(6) self.assertEqual(self.twoItemList.getPosition(0), 6) self.assertEqual(self.twoItemList.getPosition(1), 2) self.assertEqual(self.twoItemList.getPosition(2), 9) def testEmptyInsertAfter(self): self.assertFalse(self.emptyList.insertAfter(1, 3)) def testOneInsertAfter(self): self.assertTrue(self.oneItemList.insertAfter(2, 0)) self.assertEqual(self.oneItemList.getPosition(1), 2) self.assertFalse(self.oneItemList.find(7)) def testTwoInsertAfter(self): self.assertTrue(self.twoItemList.insertAfter(7, 0)) self.assertEqual(self.twoItemList.getPosition(1), 7) self.assertFalse(self.twoItemList.find(3)) def testEmptyRemoveBeginning(self): self.assertFalse(self.emptyList.removeBeginning()) def testOneRemoveBeginning(self): self.assertTrue(self.oneItemList.removeBeginning()) self.assertFalse(self.oneItemList.getPosition(0)) def testTwoRemoveBeginning(self): self.assertTrue(self.twoItemList.removeBeginning()) self.assertEqual(self.twoItemList.getPosition(0), 9) def testEmptyRemoveEnd(self): self.assertFalse(self.emptyList.removeEnd()) def testOneRemoveEnd(self): self.assertTrue(self.oneItemList.removeEnd()) self.assertFalse(self.oneItemList.getPosition(0)) def testTwoRemoveEnd(self): self.assertTrue(self.twoItemList.removeEnd()) self.assertEqual(self.twoItemList.getPosition(0), 2) #def testRemoveAfter(self): def testEmptyFind(self): self.assertFalse(self.emptyList.find(0)) def testOneFind(self): self.assertFalse(self.oneItemList.find(0)) self.assertTrue(self.oneItemList.find(3)) def testTwoFind(self): self.assertTrue(self.fiveItemList.find(8)) self.assertFalse(self.fiveItemList.find(3)) def testFiveFind(self): self.assertTrue(self.fiveItemList.find(0)) self.assertFalse(self.fiveItemList.find(2))
class TestDoublyLinkedList(unittest.TestCase):
def setUp(self):
self.my_list = DoublyLinkedList()
def test_basic_initialization_and_repr(self):
self.assertEqual(repr(self.my_list), '[]')
def test_append(self):
self.my_list.append(4)
self.my_list.append(3)
self.my_list.append(7)
self.my_list.append(-17)
self.assertEqual(repr(self.my_list), '[4, 3, 7, -17]')
def test_prepend(self):
self.my_list.prepend(4)
self.my_list.prepend(3)
self.my_list.prepend(7)
self.my_list.prepend(-17)
self.assertEqual(repr(self.my_list), '[-17, 7, 3, 4]')
def test_insert_after(self):
self.my_list.insert_after(None, 4)
self.my_list.insert_after(None, 3)
self.my_list.insert_after(self.my_list.tail, 7)
self.my_list.insert_after(self.my_list.head, -17)
self.assertEqual(repr(self.my_list), '[3, -17, 4, 7]')
def test_insert_sorted(self):
self.my_list.insert_after(None, 4)
self.my_list.insert_after(None, 3)
self.my_list.insert_after(None, 7)
self.assertEqual(repr(self.my_list), '[7, 3, 4]')
self.my_list.insert_sorted(2)
self.my_list.insert_sorted(8)
self.assertEqual(repr(self.my_list), '[2, 7, 3, 4, 8]')
self.my_list.remove(self.my_list.head)
self.my_list.remove(self.my_list.head)
self.my_list.remove(self.my_list.head)
self.my_list.remove(self.my_list.head)
self.my_list.remove(self.my_list.head)
self.my_list.insert_sorted(8)
self.my_list.insert_sorted(7)
self.my_list.insert_sorted(6)
self.my_list.insert_sorted(5)
self.assertEqual(repr(self.my_list), '[5, 6, 7, 8]')
def test_remove(self):
self.my_list.append(4)
self.my_list.append(3)
self.my_list.append(7)
self.my_list.append(-17)
self.assertEqual(repr(self.my_list), '[4, 3, 7, -17]')
self.my_list.remove(self.my_list.head)
self.assertEqual(repr(self.my_list), '[3, 7, -17]')
self.my_list.remove(self.my_list.head.next)
self.assertEqual(repr(self.my_list), '[3, -17]')
self.my_list.remove(self.my_list.tail)
self.assertEqual(repr(self.my_list), '[3]')
self.my_list.remove(self.my_list.head)
self.my_list.remove(self.my_list.head)
self.assertEqual(repr(self.my_list), '[]')
def test_array(self):
self.my_list.append(4)
self.my_list.append(3)
self.my_list.append(7)
self.my_list.append(-17)
self.assertEqual(self.my_list.array(), [4, 3, 7, -17])
def test_reverse_array(self):
self.my_list.append(4)
self.my_list.append(3)
self.my_list.append(7)
self.my_list.append(-17)
self.assertEqual(self.my_list.reverse_array(), [-17, 7, 3, 4])
def test_search(self):
self.my_list.append(4)
self.my_list.append(3)
self.my_list.append(-17)
self.my_list.append(7)
self.assertEqual(self.my_list.search(4).data, 4)
self.assertEqual(self.my_list.search(3).data, 3)
self.assertEqual(self.my_list.search(-17).data, -17)
self.assertEqual(self.my_list.search(17), None)
def test_reverse(self):
self.my_list.append(4)
self.my_list.append(3)
self.my_list.append(7)
self.my_list.append(-17)
self.assertEqual(repr(self.my_list), '[4, 3, 7, -17]')
self.my_list.reverse()
self.assertEqual(repr(self.my_list), '[-17, 7, 3, 4]')
self.my_list.reverse()
self.assertEqual(repr(self.my_list), '[4, 3, 7, -17]')
def test_remove_duplicates(self):
self.my_list.append(4)
self.my_list.append(3)
self.my_list.append(3)
self.my_list.append(3)
self.my_list.append(7)
self.my_list.append(-17)
self.assertEqual(repr(self.my_list), '[4, 3, 3, 3, 7, -17]')
self.my_list.remove_duplicates()
self.assertEqual(repr(self.my_list), '[4, 3, 7, -17]')
class Deque:
def __init__(self, iterable=None):
# Initialize a new Doubly linked list to store the items
self.list = DoublyLinkedList()
if iterable is not None:
for item in iterable:
self.append(item)
def __repr__(self):
"""Return a string representation of this stack."""
return 'Stack({} items, top={}, last={}'.format(
self.length(), self.peek_first(), self.peek_last())
def is_empty(self):
"""Return True if this stack is empty, or False otherwise."""
return self.list.is_empty()
def length(self):
"""Return the number of items in this stack."""
return self.list.size
def append(self, item):
""" Insert the given item to the end of the double ended queue"""
self.list.append(item)
def prepend(self, item):
""" Insert the given item to the end of the double ended queue"""
self.list.prepend(item)
def peek_first(self):
"""Return the item on the top of this queue without removing it,
or None if this queue is empty."""
if self.is_empty():
return None
else:
return self.list.head.data
def peek_last(self):
"""Return the item on the end of this queue without removing it,
or None if this queue is empty."""
if self.is_empty():
return None
else:
return self.list.tail.data
def pop_first(self):
"""Remove and return the item on the top of this queue,
or raise ValueError if this queue is empty.
Running time: O(1) – Since the targeted node is the head of the linked list"""
if self.is_empty():
raise ValueError('Stack is empty')
else:
top_value = self.list.head.data
self.list.delete(top_value)
return top_value
def pop_last(self):
"""Remove and return the item on the end of this queue,
or raise ValueError if this queue is empty.
Running time: O(1) – Since the targeted node is the tail of the linked list"""
if self.is_empty():
raise ValueError('Stack is empty')
else:
top_value = self.list.tail.data
self.list.delete(top_value)
return top_value
def test_iter(self):
llist = DoublyLinkedList()
llist.append('A')
llist.append('B')
self.assertEqual(repr(llist), 'A, B')
def test_append_start_filled(self):
linkedlist = DoublyLinkedList([1, 2, 3])
for i in range(10):
linkedlist.append(i)
llist = DoublyLinkedList()
llist.head = Node(1)
second = Node(2)
third = Node(4)
llist.head.next = second
second.next = third
llist.print_list()
llist.insert_after(2, 3)
print('\nInserting 3 after 2 ..')
llist.print_list()
llist.append(5)
print('\nAppending 5 ..')
llist.print_list()
llist.insert_before(2, 0)
print('\nInserting 0 before 2 ..')
llist.print_list()
llist.delete_node_position(4)
print('\nDeleting node at position 4 ..')
llist.print_list()
print('\nCount:', llist.get_count())
llist.delete_node(4)
print('\nDeleting 4 ..')
def test_add_after_last_node(self):
llist = DoublyLinkedList()
llist.append('A')
llist.append('B')
llist.add_after_node('B', 'C')
self.assertEqual(repr(llist), 'A, B, C')
from doubly_linked_list import DoublyLinkedList
my_list = DoublyLinkedList()
my_list.print()
for i in range(10):
my_list.append(i + 1)
my_list.print()
for i in range(10):
my_list.prepend(i + 1)
my_list.print()
value = my_list.access(3)
print('my_list.access(3) = ' + str(value))
my_list.insert(8, 128)
my_list.print()
my_list.remove(4)
my_list.print()
my_list.set_head(10)
my_list.print()
my_list.print_inverse()
def test_append_start_empty(self):
linkedlist = DoublyLinkedList()
for i in range(10):
linkedlist.append(i)
