def testAppend(self):
dl = ll.DoublyLinkedList()
a, b, c, d = ll.Node('a'), ll.Node('b'), ll.Node('c'), ll.Node('d')
dl.append_list([a, b, c, d])
self.assertEqual(dl.values(), ['a', 'b', 'c', 'd'])
self.assertEqual(dl.head, a)
self.assertEqual(dl.tail, d)
def create_linked_list_from_number(number):
"""
Function to create a linked list out of given number.
Parameters
----------
number: ``int``
Number of which linked list will be created.
Returns
-------
Head of type ``node`` of resultant linked list.
Time Complexity
---------------
O(D), where D is the number of digits in the number.
Space Complexity
----------------
O(D)
"""
head = None
while number != 0:
if not head:
head = ll.Node(number % 10)
pointer = head
else:
pointer.next = ll.Node(number % 10)
pointer = pointer.next
number = number // 10
return head
def test_remove_node(self):
my_list = linked_list.List(linked_list.Node(5))
node = linked_list.Node(7)
my_list.append(node)
my_list.append(linked_list.Node(9))
my_list.remove(node)
self.assertEqual(my_list.get_head().get_data(), 5)
self.assertEqual(my_list.get_head().get_next().get_data(), 9)
self.assertEqual(my_list.get_tail().get_data(), 9)
def testPop(self):
n1, n2, n3 = ll.Node(1), ll.Node(2), ll.Node(3)
llist = ll.LinkedList(n1)
llist.insert_at_tail(n2)
llist.insert_at_tail(n3)
res = llist.pop()
self.assertEqual(res.value, n1.value)
self.assertEqual(res.next, None)
self.assertEqual(n2.next, n3)
def add_edge(self, v, w):
if self.vertices[v] is None:
self.vertices[v] = linked_list.Node(w)
else:
self.vertices[v] = self.vertices[v].insert(w)
if self.vertices[w] is None:
self.vertices[w] = linked_list.Node(v)
else:
self.vertices[w] = self.vertices[w].insert(v)
def testInsertAfter(self):
llist = self.exampleList()
found_node = llist.search(5)
llist.insert_after(found_node, ll.Node(10))
self.assertEqual(llist.to_list(), [0, 2, 5, 10, 7])
self.assertEqual(llist.tail.value, 7)
# Test insertion after tail
found_node = llist.search(7)
llist.insert_after(found_node, ll.Node(12))
self.assertEqual(llist.to_list(), [0, 2, 5, 10, 7, 12])
self.assertEqual(llist.tail.value, 12)
def partition_linked_list(head, x):
"""
Function to partition a linked list around a given value.
Parameters
----------
head: ``Node``
Head node of linked list.
x: ``int``
Integer value around which linked list needs to be partitioned.
Returns
-------
Head node of type ``Node`` of partitioned linked list.
Time Complexity
---------------
O(N)
Space Complexity
----------------
O(N)
"""
# Create null head nodes for paritioned linked lists.
smaller_x_head = None
remaining_head = None
# Traverse original linked list
while head:
print(head.value)
# If current node's value is smallers than x, then create a node with
# this value and attach it to the smaller_x linked list.
if head.value < x:
if smaller_x_head:
smaller_x_pointer.next = ll.Node(head.value)
smaller_x_pointer = smaller_x_pointer.next
else:
smaller_x_head = ll.Node(head.value)
smaller_x_pointer = smaller_x_head
# Otherwise, attach it to the remaining linked list
else:
if remaining_head:
remaining_x_pointer.next = ll.Node(head.value)
remaining_x_pointer = remaining_x_pointer.next
else:
remaining_head = ll.Node(head.value)
remaining_x_pointer = remaining_head
head = head.next
# Connect the 2 linked lists together
smaller_x_pointer.next = remaining_head
return smaller_x_head
def testInsertAtHead(self):
dl = ll.DoublyLinkedList()
a, b, c, d = ll.Node('a'), ll.Node('b'), ll.Node('c'), ll.Node('d')
e = ll.Node('e')
dl.insert_at_head(a)
self.assertEqual(dl.head, a)
self.assertEqual(dl.tail, a)
dl.append_list([b, c, d])
self.assertEqual(dl.values(), ['a', 'b', 'c', 'd'])
dl.insert_at_head(e)
self.assertEqual(dl.values(), ['e', 'a', 'b', 'c', 'd'])
def testInsertAtTail(self):
# Empty list
llist = ll.LinkedList()
llist.insert_at_tail(ll.Node(10))
self.assertEqual(llist.to_list(), [10])
self.assertEqual(llist.head.value, 10)
self.assertEqual(llist.tail.value, 10)
# Normal list
llist = self.exampleList()
llist.insert_at_tail(ll.Node(10))
self.assertEqual(llist.to_list(), [0, 2, 5, 7, 10])
self.assertEqual(llist.tail.value, 10)
def testInsertAtHead(self):
llist = self.exampleList()
llist.insert_at_head(ll.Node(10))
self.assertEqual(llist.to_list(), [10, 0, 2, 5, 7])
self.assertEqual(llist.head.value, 10)
self.assertEqual(llist.tail.value, 7)
# Test insertion in empty list
llist = ll.LinkedList()
llist.insert_at_head(ll.Node(10))
self.assertEqual(llist.to_list(), [10])
self.assertEqual(llist.head.value, 10)
self.assertEqual(llist.tail.value, 10)
def testDelete(self):
dl = ll.DoublyLinkedList()
a, b, c, d = ll.Node('a'), ll.Node('b'), ll.Node('c'), ll.Node('d')
dl.append_list([a, b, c, d])
self.assertEqual(dl.values(), ['a', 'b', 'c', 'd'])
dl.delete(b)
self.assertEqual(dl.values(), ['a', 'c', 'd'])
dl.delete(a)
self.assertEqual(dl.values(), ['c', 'd'])
self.assertEqual(dl.head, c)
dl.delete(d)
self.assertEqual(dl.values(), ['c'])
self.assertEqual(dl.head, c)
self.assertEqual(dl.tail, c)
def add_ints(head1, head2):
output = linked_list.Node(None)
new_head = output
carry = 0
while head1 != None or head2 != None or carry > 0:
h1_val = (head1.value if head1 else 0)
h2_val = (head2.value if head2 else 0)
node_sum = (h1_val + h2_val + carry) % 10
carry = int((h1_val + h2_val + carry) / 10)
output.next = linked_list.Node(node_sum)
output = output.next
head1 = (None if head1 == None else head1.next)
head2 = (None if head2 == None else head2.next)
return new_head.next
def partition(head, x):
first = head.value
second = head.next.value
if first > second:
first, second = second, first
high = linked_list.Node(second, None)
low = linked_list.Node(first, high)
head = head.next.next
while head:
if head.value >= x:
high.next = linked_list.Node(head.value, None)
high = high.next
else:
low = linked_list.Node(head.value, low)
head = head.next
return low
def test_delete():
test_ll = linked_list.create_ll(10)
temp = test_ll.next
test_ll.next = linked_list.Node(100, temp)
linked_list.print_ll(test_ll)
print("deleted ll")
new_head = delete_node(test_ll, 100)
linked_list.print_ll(test_ll)
def _run_test(data, correct):
l = linked_list.List()
for item in data:
node = linked_list.Node(item)
l.add_last(node)
assert is_palindrom(l) == correct
def add_adjecency(self, vertex):
adge = self.adjacency_list.head
while (adge):
if adge.cargo == vertex:
raise ValueError("adge already exists for:" + vertex.name)
adge = adge.next
self.adjacency_list.add(ll.Node(vertex))
vertex.in_degree += 1
def enqueue(self, data):
node = linked_list.Node(data)
if self.isEmpty():
self.queue.add_node_by_obj(node)
self.last = node
self.first = node
return
self.last.next = node
self.last = node
def object_priority_queue_test():
queue = ObjectPriorityQueue()
a = [4,8,9,2,4,88,23,22]
for i in a:
queue.enqueue(linked_list.Node(i))
for i in range(len(a) -1 ):
print(traverse_heap(queue.heap.heap))
print(queue.dequeue().data)
#object_priority_queue_test()
def test_heap():
h = MinObjectHeap()
#h.heap
a = [5, 7, 9, 1, 3, 4, 50, -1]
for i in a:
x = linked_list.Node(i)
h.push(x)
print(h.heap)
traverse_heap(h.heap)
h.pop()
traverse_heap(h.heap)
h.pop()
traverse_heap(h.heap)
def add(head1, head2):
if not head1 or not head2:
return "Linked List are empty"
curr = None
carry = 0
while (head1 or head2):
total_sum = 0
if head1:
total_sum += head1.data
if head2:
total_sum += head2.data
sum = carry + (total_sum % 10)
carry = total_sum / 10
temp = linked_list.Node(sum)
if curr:
curr.nextnode = temp
curr = curr.nextnode
else:
ll = linked_list.LinkedList(temp)
curr = ll.head
if head1:
head1 = head1.nextnode
if head2:
head2 = head2.nextnode
if carry:
curr.nextnode = linked_list.Node(carry)
return ll
def sum_lists(l1, l2, carry=0):
if l1 is None and l2 is None:
return None
def expand_list(l):
if l is None:
return 0, None
else:
return l.value, l.next
l1_value, l1_next = expand_list(l1)
l2_value, l2_next = expand_list(l2)
s = divmod(l1_value + l2_value + carry, 10)
passed_carry = 0
if s >= 10:
s -= 10
passed_carry = 1
return linked_list.Node(s, sum_lists(l1_next, l2_next, passed_carry))
def insert(self, key, value):
if key in self.dict:
# Data already in LRU: don't update but move to front of line
node = self.dict[key]
self.dll.delete(node)
self.dll.insert_at_head(node)
return
if len(self.dict) >= self.capacity:
# Evict LRU node if at capacity
lru_node = self.dll.tail
self.dll.delete(lru_node)
self.dict.pop(lru_node.data.key)
# Insert new node at head of queue
node = ll.Node(LRUItem(key=key, value=value))
self.dict[key] = node
self.dll.insert_at_head(node)
return
#it reaches a new node.
while current.next:
current = current.next
counter += 1
#make sure m is not larger than the counter, or number of nodes in
#the linked list
if m > counter:
print "Only {} nodes. Can't find {}.".format(counter, m)
return None
else:
return ll.get_position(counter - m + 1).data
#Test function
print "Test Question 5"
n1 = LL.Node(1)
n2 = LL.Node(2)
n3 = LL.Node(3)
n4 = LL.Node(4)
ll = LL.LinkedList(n1)
ll.append(n2)
ll.append(n3)
ll.append(n4)
print question5(ll, 3)
#2
print question5(ll, 1)
#4
print question5(ll, 8)
#Prints 'Only 4 nodes. Can't find 8' and returns None
print question5(ll, 2)
#3
def test_node_get_data(self):
node = linked_list.Node(10)
self.assertTrue(node.get_data(), 10)
def test_list_creation(self):
my_list = linked_list.List(linked_list.Node(2))
self.assertEqual(my_list.get_head().get_data(), 2)
self.assertEqual(my_list.get_tail().get_data(), 2)
def test_init_node():
with pytest.raises(ValueError):
linked_list.Node("f", 4)
import linked_list
import random
import cmath
if __name__ == '__main__':
data1 = [1, 2, 3]
#create a linked list and assigning data to nodes
llist = linked_list.LinkedList()
llist.head = linked_list.Node(data1)
second = linked_list.Node([2, 4, 5])
third = linked_list.Node([3, 5, 7])
#Linking the nnodes
llist.head.next = second
second.next = third
print("Original linked list:")
llist.printList()
data1.append(4)
print("Original linked list after appending an element to a node:")
llist.printList()
llist.append([6,7,8])
print("After appending :")
llist.printList()
print("After inserting :")
llist.insertAfter(llist.head.next, [11,12,13])
def test_str_node():
assert str(linked_list.Node(3)) == "(3)"
def testInit(self):
a = ll.Node('a')
d = ll.DoublyLinkedList(a)
self.assertEqual(d.values(), ['a'])
self.assertEqual(d.head, a)
self.assertEqual(d.tail, a)
def test_remove_head(self):
my_list = linked_list.List(linked_list.Node(5))
node = linked_list.Node(7)
my_list.append(node)
my_list.remove(linked_list.Node(5))
self.assertEqual(my_list.get_head().get_data(), 7)
