def test_search():
"""Test Linked_List length method."""
from linked_list import Linked_List
test_list = Linked_List()
test_list.insert(data[0])
test_list.insert(data[1])
assert test_list.search(data[0]) == data[0]
def test_display():
"""Test Linked_List display method."""
from linked_list import Linked_List
test_list = Linked_List()
test_list.insert(data[0])
test_list.insert(data[1])
assert test_list.display() == "(123, 456)"
def test_insert():
"""Test Linked_List insert method."""
from linked_list import Linked_List
from linked_list import Node
test_list = Linked_List()
test_list.insert(data[0])
assert isinstance(test_list.head, Node)
def test_display():
a = Linked_List()
a.display()
a.insert('a')
a.insert(1)
a.display()
assert a.display_prep() == "(1, 'a')"
def reversed(self):
_result = Linked_List() # init empty list
current = self._head # init start
while current is not None:
_result.add_head(current._value)
current = current._next # incr
return _result
def test_print():
lst = Linked_List()
lst.insert('A')
lst.insert((1, 2, 3))
lst.insert(42)
lst.insert('Bob Dole')
assert str(lst) == "('Bob Dole', 42, (1, 2, 3), 'A')"
def test_str():
a = Linked_List()
print a
a.insert('When A Café')
a.insert('b')
a.insert(2)
print a
assert a.display_prep() == "(2, 'b', 'When A Café')"
def test_insert():
lst = Linked_List()
lst.insert(7)
assert lst.head.datum == 7
lst.insert('Sir Sean Connery')
assert lst.head.datum == 'Sir Sean Connery'
def test_as_list(self):
ll = Linked_List()
assert ll.as_list() == []
ll.append('A')
assert ll.as_list() == ['A']
ll.append('B')
assert ll.as_list() == ['A', 'B']
ll.append('C')
assert ll.as_list() == ['A', 'B', 'C']
def test_find(self):
ll = Linked_List()
ll.append('A')
ll.append('B')
ll.append('C')
assert ll.find(lambda item: item == 'B') == 'B'
assert ll.find(lambda item: item < 'B') == 'A'
assert ll.find(lambda item: item > 'B') == 'C'
assert ll.find(lambda item: item == 'D') is None
def test_length(self):
ll = Linked_List()
assert ll.length() == 0
ll.append('A')
assert ll.length() == 1
ll.append('B')
assert ll.length() == 2
ll.append('C')
assert ll.length() == 3
def test_remove():
"""Test Linked_List remove method."""
from linked_list import Linked_List
test_list = Linked_List()
test_list.insert(data[0])
test_list.insert(data[1])
test_list.insert(data[2])
test_list.remove(data[1])
assert test_list.size() == 2
def test_pop():
lst = Linked_List()
lst.insert(7)
lst.insert('Sir Sean Connery')
val1 = lst.pop()
val2 = lst.pop()
assert val1 == 'Sir Sean Connery'
assert val2 == 7
assert lst.head is None
def polynomial(a, x, n):
if a >= n:
P = Linked_List()
for i in range(n, 0, -1):
node = a * x ** i
P.add(node)
a -= 1
return P
else:
return ValueError("a>=n")
def test_prepend(self):
ll = Linked_List()
ll.prepend('C')
assert ll.head.data == 'C'
assert ll.tail.data == 'C'
ll.prepend('B')
assert ll.head.data == 'B'
assert ll.tail.data == 'C'
ll.prepend('A')
assert ll.head.data == 'A'
assert ll.tail.data == 'C'
def deleteDuplicates(self, head):
if not head:
return None
tracer = head
outputList = Linked_List()
while (tracer.next != None):
if (tracer.val != tracer.next.val):
outputList.AddTail(tracer.val)
tracer = tracer.next
outputList.AddTail(tracer.val)
return outputList.head
def test_size():
s = Linked_List()
assert s.size() is 0
for something in range(100):
s.insert(something)
assert s.size() is 100
s.pop()
assert s.size() is 99
s.insert(0)
assert s.size() is 100
m = List_Node(0)
s.remove(m)
assert s.size() is 99
def __init__(self):
"""
Generates an empty hash-table.
"""
self.table = [Linked_List() for _ in range(4)]
self.hash_size = 2
self.min_size = 1
self.max_size = 4
self.num_keys = 0
self.rand = randrange(1, max_int)
self.word_size = int(log(max_int, 2))
self.h = lambda key: (self.rand * key % max_int) >> (self.word_size -
self.hash_size)
def rehash(self):
"""
Rehashes all keys in the hash-table.
"""
self.num_keys = 0
table = self.table
self.table = [Linked_List() for slot in range(self.max_size)]
for slot in table:
element = slot.head
while element:
self.insert(element.key, element.value)
element = element.next
def test_search():
lst = Linked_List()
lst.insert(7)
lst.insert(4)
lst.insert('Sir Sean Connery')
lst.insert((1, 2, 3))
lst.insert('Harrison Ford')
n1 = lst.search('Sir Sean Connery')
n2 = lst.search(7)
assert n1.datum == 'Sir Sean Connery'
assert n2.pointer is None
assert lst.search('Batman') is None
def test_remove():
lst = Linked_List()
lst.insert(7)
lst.insert(4)
lst.insert('Sir Sean Connery')
lst.insert((1, 2, 3))
lst.remove(4)
lst.remove('Sir Sean Connery')
assert lst.size() == 2
assert str(lst) == "((1, 2, 3), 7)"
lst.remove((1, 2, 3))
assert str(lst) == "(7,)"
def create_linked_list(fencers_csv):
''' Creates a sorted linked list from a CSV file. '''
with open(fencers_csv) as csv_file:
fencer_list = Linked_List()
reader = csv.reader(csv_file, delimiter='\t')
for row in reader:
fencer = {
'last_name': row[0].split(',')[0],
'first_name': row[0].split(',')[1],
'team': row[0].split(',')[2],
'rank': row[0].split(',')[3]
}
fencer_list.insert(fencer)
return fencer_list
def test_delete(self):
ll = Linked_List()
ll.append('A')
ll.append('B')
ll.append('C')
print(ll.as_list())
ll.delete('A')
print(ll.as_list())
assert ll.head.data == 'B'
assert ll.tail.data == 'C'
ll.delete('C')
assert ll.head.data == 'B'
assert ll.tail.data == 'B'
ll.delete('B')
assert ll.head is None
assert ll.tail is None
with self.assertRaises(ValueError):
ll.delete('D')
def test_remove():
a = Linked_List()
a.insert('val')
assert a.head
b = List_Node('val')
a.remove(b)
assert not a.head
for something in range(100):
a.insert(something)
c = List_Node(99)
a.remove(c)
assert a.head.data is 98
d = List_Node(0)
a.remove(d)
temp = a.head
while temp.next:
temp = temp.next
assert temp.data is 1
def check_linked_list_cycle(first_node):
# """Returns True if the linked list is a circular linked list, else
# it returns False.
# >>> check_linked_list_cycle(first_node)
# False
# """
ll = Linked_List()
first_node = ll.first_node()
slow_runner = first_node
fast_runner = first_node
while fast_runner != None and fast_runner.next != None:
slow_runner = slow_runner.next
fast_runner = fast_runner.next.next
if fast_runner == slow_runner:
return True
return False
def test_size():
lst = Linked_List()
lst.insert(0)
lst.insert(1)
lst.insert(45)
lst.insert('turds')
assert lst.size() == 4
assert lst.head.datum == 'turds'
lst.pop()
lst.pop()
assert lst.size() == 2
assert lst.head.datum == 1
lst.insert('boobies')
assert lst.size() == 3
lst.insert('i am mature')
assert lst.size() == 4
lst.pop()
assert lst.head.datum == 'boobies'
from RemoveDuplicatesfromSortedList import Solution
from linked_list import ListNode, Linked_List
a = Linked_List()
a.AddTail(1)
a.AddTail(1)
a.AddTail(1)
a.AddTail(1)
a.AddTail(1)
a.AddTail(1)
a.AddTail(1)
a.AddTail(1)
a.AddTail(2)
a.AddTail(3)
a.AddTail(3)
temp = Solution()
tracer = temp.deleteDuplicates(a.head)
while tracer.next != None:
print(tracer.val)
tracer = tracer.next
print(tracer.val)
def test_linked_list():
"""
Code to test each part of the linked list class
"""
# empty()
ll = Linked_List()
assert ll.empty() == True
ll.head = Node(3)
assert ll.empty() == False
# next_is_empty()
assert ll.head.next_is_empty() == True
ll.head.tail = Node(4)
assert ll.head.next_is_empty() == False
# size()
ll.head.tail.tail = Node(5)
assert ll.size() == 3
assert Linked_List().size() == 0
size_one = Linked_List()
size_one.head = Node(18)
assert size_one.size() == 1
# value_at()
assert ll.value_at(0) == 3
assert ll.value_at(1) == 4
assert ll.value_at(2) == 5
assert ll.value_at(3) == "IndexError: Index is too large or incorrect. Should be an integer less than size of linkedlist"
# push_front()
ll.push_front(2)
assert ll.value_at(0) == 2
assert ll.value_at(1) == 3
assert ll.value_at(2) == 4
assert ll.value_at(3) == 5
assert ll.size() == 4
# pop_front()
front_value = ll.pop_front()
assert front_value == 2
assert ll.size() == 3
assert ll.value_at(0) == 3
# push_back()
ll.push_back(6)
assert ll.size() == 4
assert ll.value_at(3) == 6
# pop_back()
back_value = ll.pop_back()
assert ll.size() == 3
assert back_value == 6
# front()
front_value = ll.front()
assert front_value == 3
assert ll.size() == 3
# back()
back_value = ll.back()
assert back_value == 5
assert ll.size() == 3
# insert_at()
ll.insert_at(0, 2)
assert ll.size() == 4
assert ll.value_at(0) == 2
ll.insert_at(1, 2.5)
assert ll.size() == 5
assert ll.value_at(1) == 2.5
assert ll.value_at(2) == 3
# erase()
ll.remove(0)
assert ll.size() == 4
assert ll.value_at(0) == 2.5
ll.remove(1)
assert ll.size() == 3
assert ll.value_at(1) == 4
# value_n_from_end()
n = ll.value_n_from_end(0)
assert n == 5
assert ll.size() == 3
# reverse()
reversed = ll.reverse()
assert reversed.size() == 3
assert reversed.value_at(0) == 5
assert reversed.value_at(1) == 4
assert reversed.value_at(2) == 2.5
# remove_value(value)
reversed.remove_value(4)
assert reversed.size() == 2
assert reversed.value_at(0) == 5
assert reversed.value_at(1) == 2.5
def __init__(self, iterable=None):
"""Initialize stack as a Linked_List-esque object."""
self._container = Linked_List(iterable)
def test_init():
lst = Linked_List()
assert lst.head is None
