def test_remove():
ll = LinkList()
helper_insert_many(ll)
actual = ll.remove('5')
expected = True
assert actual == expected
assert ll.count() == 9
class LinkListStack(object):
def __init__(self, size):
self.top = 0
self._size = size
self._items = LinkList()
def __len__(self):
return self.top
def push(self, value):
if self.top >= self._size:
raise Exception("stack is full")
self._items.append(value)
self.top += 1
def pop(self):
if self.top <= 0:
raise Exception("stack is empty")
v = self._items.pop()
self.top -= 1
return v
def is_empty(self):
return self.top == 0
def test_kthFromEnd_OneLinkList():
ll = LinkList()
ll.insert("blah")
#Where the linked list is of a size 1
actual = ll.kthFromEnd(0)
expected = "blah"
assert actual == expected
def test_peekHead():
ll = LinkList()
helper_insert_many(ll)
expectedStr = "9"
expectedBool = True
actualBool, actualStr = ll.peekHead()
assert expectedStr == actualStr
assert expectedBool == actualBool
def test_toJSON():
# Dump the LinkList to JSON and compare to what it should be
ll = LinkList()
helper_insert_many(ll)
actual = ll.toJSON()
expected = """{ "head": { "value": "9", "next": { "value": "8", "next": { "value": "7", "next": { "value": "6", "next": { "value": "5", "next": { "value": "4", "next": { "value": "3", "next": { "value": "2", "next": { "value": "1", "next": { "value": "0", "next": null, "prev": null }, "prev": null }, "prev": null }, "prev": null }, "prev": null }, "prev": null }, "prev": null }, "prev": null }, "prev": null }, "prev": null }, "comparison_func": null }"""
print(actual)
print(expected)
assert expected == actual
def test_traverse():
actual = []
def visit(value):
actual.append(value)
ll = LinkList()
helper_insert_many(ll)
ll.traverse(visit)
expected = ['9', '8', '7', '6', '5', '4', '3', '2', '1', '0']
assert actual == expected
def test_append():
ll = LinkList()
ll.insert('2')
ll.insert('3')
ll.insert('1')
ll.append('5')
expected = '1,3,2,5'
actual = ll.toStr()
assert expected == actual
def test_insert_many():
ll = LinkList()
helper_insert_many(ll)
assert ll.count() == 10
assert ll.head.value == '9'
assert ll.head.next.value == '8'
assert ll.head.next.next.value == '7'
assert ll.head.next.next.next.value == '6'
assert ll.head.next.next.next.next.value == '5'
assert ll.head.next.next.next.next.next.value == '4'
assert ll.head.next.next.next.next.next.next.value == '3'
assert ll.head.next.next.next.next.next.next.next.value == '2'
assert ll.head.next.next.next.next.next.next.next.next.value == '1'
assert ll.head.next.next.next.next.next.next.next.next.next.value == '0'
assert ll.head.next.next.next.next.next.next.next.next.next.next is None
def test_link_list_size(self) -> None:
print('\Insert element in existing LinkList')
elements :List[int] =[ ]
ll : LinkList = LinkList()
size:int = random.randrange(0,20)
elements = [random.randrange(0,101) for _ in range(size)]
print('No of elements to be inserted in LinkList are {0}'.format(len(elements)))
print('Elements of linkList are :{}'.format(elements))
ll.create_link_list_from_list(elements)
size_recurse : int = ll.find_linklist_size_recursively()
print('Size of LinkList is {0}'.format(size_recurse))
def helper_kthFromEnd():
ll = LinkList()
ll.insert("2")
ll.insert("8")
ll.insert("3")
ll.insert("1")
return ll
class Queue():
def __init__(self):
self._data = LinkList()
def count(self) -> int:
return self._data.count()
def toStr(self) -> str:
return self._data.toStr()
def enqueue(self, val) -> bool:
# Add a value to the queue
return self._data.append(val)
def dequeue(self, val) -> bool:
# Remove entry from queue with a given value
# NOTE: will only remove the first element found with val
return self._data.remove(val)
def peek(self) -> [bool, object]:
# Get value from the head of the queue (without removing it)
return self._data.peekHead()
def test_link_list_from_list(self)->None:
print('\nInserting Elements in LinkList using Python List')
elements :List[int] =[ ]
ll : LinkList = LinkList()
#random.seed(a=1)
elements = [random.randrange(0,101) for _ in range(10)]
print('Elements are :{}'.format(elements))
ll.create_link_list_from_list(elements)
ll.print_link_list()
print('\n******************************************\n')
def test_add_elements_to_link_list_at_end(self)-> None:
print('\Insert element in existing LinkList')
elements :List[int] =[ ]
ll : LinkList = LinkList()
#random.seed(a=1)
elements = [random.randrange(0,101) for _ in range(10)]
print('Elements of linkList are :{}'.format(elements))
ll.create_link_list_from_list(elements)
new_element:int = random.randrange(0,101)
print('Adding new element {0}'.format(new_element))
ll.insert(new_element)
print('Elements of linkList are adding new element')
ll.print_link_list()
def test_delete_node(self) -> None:
print('\Insert element in existing LinkList')
elements :List[int] =[ ]
ll : LinkList = LinkList()
#random.seed(a=1)
elements = [random.randrange(0,101) for _ in range(10)]
print('Elements of linkList are :{}'.format(elements))
ll.create_link_list_from_list(elements)
element_to_delete:int = random.choice(elements)
print('Deleting element {0} from LinkList'.format(element_to_delete))
ll.delete_node(element_to_delete)
print('Elements of linkList after deleting element')
ll.print_link_list()
def test_add_elements_to_link_list_at_random_place(self) -> None:
print('\Insert element in existing LinkList')
elements :List[int] =[ ]
ll : LinkList = LinkList()
#random.seed(a=1)
elements = [random.randrange(0,101) for _ in range(10)]
print('Elements of linkList are :{}'.format(elements))
ll.create_link_list_from_list(elements)
after_element:int = random.choice(elements)
new_element:int = random.randrange(0,100)
print('Adding new element {0} after exisiting element {1}'.format(new_element,after_element))
ll.insert(data=new_element,prev_node_data=after_element)
print('Elements of linkList are adding new element')
ll.print_link_list()
def reverse_linklist_iteratively(self)-> None:
print('\Insert element in existing LinkList')
elements :List[int] =[ ]
ll : LinkList = LinkList()
size:int = random.randrange(0,20)
elements = [random.randrange(0,101) for _ in range(size)]
#elements = [85, 13, 53, 86, 58, 48]
print('No of elements to be inserted in LinkList are {0}'.format(len(elements)))
print('Elements of linkList are :{}'.format(elements))
ll.create_link_list_from_list(elements)
ll.print_link_list()
ll.reverse_linklist_iteratively()
print('LinkList after reversing iteratively')
ll.print_link_list()
class Stack():
_data = None
def __init__(self):
self._data = LinkList()
def count(self) -> int:
return self._data.count()
def pop(self) -> object:
b, val = self._data.peekHead()
if b:
self._data.remove(val)
return val
def push(self, val: object) -> bool:
self._data.insert(val)
return True
def peek(self) -> [bool, object]:
return self._data.peekHead()
def test_rat_list_1_remove_1(self):
"FAST: [1] and remove 1"
example = LinkList([1,])
self.assertEqual(example.dump_elements(), [1,])
example.remove_elements(1)
self.assertEqual(example.dump_elements(), [])
def test_ll_merge():
# @TODO: TEST: Merge two unequal
# @TODO: TEST: Merge one empty list
# @TODO: TEST: Merge two empty lists
# @TODO: TEST: Merge a list with just 1 item
listA = LinkList()
listA.append('apple')
listA.append('bannana')
listA.append('orange')
listB = LinkList()
listB.append('cheerios')
listB.append('frosted flakes')
listB.append('wheaties')
listA.mergeList(listA, listB)
expected = 'apple,cheerios,bannana,frosted flakes,orange,wheaties'
actual = listA.toStr()
assert expected == actual
def test_fet_list_1234_remove_5(self):
"FET: [1, 2, 3, 4] and remove 5"
example = LinkList([1, 2, 3, 4])
self.assertEqual(example.dump_elements(), [1, 2, 3, 4])
example.remove_elements(5)
self.assertEqual(example.dump_elements(), [1, 2, 3, 4])
def test_rat_list_1232_remove_2(self):
"FAST: [1, 2, 3, 2] and remove 2"
example = LinkList([1, 2, 3, 2])
self.assertEqual(example.dump_elements(), [1, 2, 3, 2])
example.remove_elements(2)
self.assertEqual(example.dump_elements(), [1, 3])
def test_peekHead_empty():
ll = LinkList()
expectedStr = ""
expectedBool = False
actualBool, actualStr = ll.peekHead()
assert expectedBool == actualBool
def test_build_link_list(self):
head = [3, 2, 0, -4]
pos = 1
link_list = LinkList().build_link_list(head, recur_index=pos)
link_list.show(limit=20)
def helper_insertBefore():
ll = LinkList()
ll.insert('1')
ll.insert('3')
ll.insert('2')
return ll
def __init__(self):
self._data = LinkList()
def test_count():
ll = LinkList()
helper_insert_many(ll)
expected = 10
actual = ll.count()
assert actual == expected
def test_includes_notfound():
ll = LinkList()
helper_insert_many(ll)
expected = False
actual = ll.includes('five')
assert expected == actual
def test_includes():
ll = LinkList()
helper_insert_many(ll)
expected = True
actual = ll.includes('5')
assert expected == actual
def test_rat_empty_list(self):
"RAT: empty list"
example = LinkList([])
self.assertEqual(example.dump_elements(), [])
example.remove_elements(0)
self.assertEqual(example.dump_elements(), [])
def test_insert():
ll = LinkList()
ll.insert('one')
assert ll.head.value == 'one'
