def __init__(self, *args, **kwargs):
super(TestInsert, self).__init__(*args, **kwargs)
self.test_list = random.sample(range(0, RANDMAX), RANDMAX // 2)
self.test_SinglyLinkedList = SinglyLinkedList()
for i in self.test_list:
self.test_SinglyLinkedList.insertAtEnd(i)
class Stack:
def __init__(self):
self.new_list = SinglyLinkedList()
def push(self, data):
self.new_list.prepend()
def pop(self):
return self.new_list.remove_from_head()
def main():
ll = SinglyLinkedList()
for i in xrange(15):
ll.append(i)
rev = reverse_linked_list(ll.head)
for i in reversed(xrange(15)):
assert i == rev.val
rev = rev.next
def main():
ll = SinglyLinkedList()
for i in xrange(15):
ll.append(i)
rev = reverse_linked_list(ll.head)
for i in reversed(xrange(15)):
assert i == rev.val
rev = rev.next
class Stacks:
def __init__(self):
self.ins = SinglyLinkedList()
def push(self, data):
self.ins.add_head(data)
def pop(self):
return self.ins.del_head()
def display(self):
return self.ins.display()
class Queues:
def __init__(self):
self.ins = SinglyLinkedList()
def enqueue(self, data):
self.ins.adding(data)
def dequeue(self):
return self.ins.del_head()
def display(self):
return self.ins.display()
def createNewLinkedList():
''' Creates a new linked list: 1 -> 2 -> 3 -> 4 -> 5. '''
print('Creating a new linked list.')
linkedList = SinglyLinkedList()
linkedList.append(1)
linkedList.append(2)
linkedList.append(3)
linkedList.append(4)
linkedList.append(5)
linkedList.iterate()
return linkedList
def main():
ll = SinglyLinkedList()
ll.append(1)
ll.append(1)
ll.append(2)
ll.append(5)
ll.append(8)
ll.append(8)
ll.append(9)
root = sorted_linked_list_to_bst(ll.head)
expected = iter([1, 1, 2, 5, 8, 8, 9])
for num in inorder_traversal(root):
assert num == expected.next()
def join(*slls):
joinedSLL = SinglyLinkedList()
disconnectedHead = None
curr = None
for sll in slls:
for data in sll:
new_node = Node(data)
if curr is None:
disconnectedHead = new_node
curr = disconnectedHead
else:
curr.next = new_node
curr = curr.next
joinedSLL.head = disconnectedHead
return joinedSLL
def createEmptyLinkedList():
''' Creates an empty linked list.'''
print('Creating Empty Linked List')
linkedList = SinglyLinkedList()
return linkedList
def main():
ll = SinglyLinkedList()
ll.append(1)
ll.append(1)
ll.append(2)
ll.append(5)
ll.append(8)
ll.append(8)
ll.append(9)
root = sorted_linked_list_to_bst(ll.head)
expected = iter([1, 1, 2, 5, 8, 8, 9])
for num in inorder_traversal(root):
assert num == expected.next()
class UniversalMethod:
def __init__(self):
self.ins = SinglyLinkedList()
def add_head(self, data):
self.ins.add_head(data)
def del_head(self):
return self.ins.del_head()
def add_end(self, data):
self.ins.adding(data)
def display(self):
return self.ins.display()
def split(sll: SinglyLinkedList, pos):
leftPart = SinglyLinkedList()
rightPart = SinglyLinkedList()
disconnectedHead1 = sll.head
disconnectedHead2 = None
curr = sll.head
try:
for _ in range(pos-1):
curr = curr.next
disconnectedHead2 = curr.next
curr.next = None
except AttributeError:
warnings.warn('Position passed is out of bounds', RuntimeWarning)
leftPart.head = disconnectedHead1
rightPart.head = disconnectedHead2
return(leftPart, rightPart)
from LinkedList import SinglyLinkedList
sample = SinglyLinkedList()
sample.append(1)
sample.prepend(3)
sample.append(2)
sample.insert(1, 5)
sample.print()
print("index 1: ",sample.access(1))
sample.set_head(2)
sample.print()
from LinkedList import SinglyLinkedList
from LinkedList import ListNode
import random
import math
def delete_middle_node(node):
node.data = node.next.data
node.next = node.next.next
ll = SinglyLinkedList()
ll.append('A')
ll.append('B')
MidNode = ListNode('C')
ll.append(MidNode)
ll.append('D')
ll.append('E')
print(ll)
delete_middle_node(MidNode)
print(ll)
def test_extend(self):
lst1 = SinglyLinkedList(1)
lst2 = SinglyLinkedList(1)
lst2.next = SinglyLinkedList(2)
self.assertFalse(are_equal(lst1, lst2))
#!/usr/bin/env python3
from LinkedList import SinglyLinkedList
import random
import string
import sys
def randomString(stringLength=10):
"""Generate a random string of fixed length """
letters = string.ascii_lowercase
return ''.join(random.choice(letters) for i in range(stringLength))
ll = SinglyLinkedList()
tries = int(sys.argv[1])
lastmin = 0.0
for i in range(tries):
prio = 1 * random.random()
print("Enqueueing at", "{:.9f}".format(prio), "\t",
"{:.2f}".format(i / tries * 100), "%")
ll.insert(prio, randomString())
for i in range(tries):
curr = ll.getFirst()
assert (curr.prio >= lastmin)
lastmin = curr.prio
print("Dequeued", curr)
# Evan Johanns # 2/20/20 from LinkedList import SinglyLinkedList lst = SinglyLinkedList() print(lst) lst.prepend(42) lst.prepend(4) print(lst)
def test_equal(self):
lst1 = SinglyLinkedList(1)
lst2 = SinglyLinkedList(1)
self.assertTrue(are_equal(lst1, lst2))
def test_one(self):
self.assertTrue(are_equal(generate_list([1]), SinglyLinkedList(1)))
def test_one_empty(self):
self.assertFalse(are_equal(SinglyLinkedList(1), None))
def test_multiple(self):
lst2 = SinglyLinkedList(1)
lst2.next = SinglyLinkedList(2)
self.assertTrue(are_equal(generate_list([1, 2]), lst2))
class LinkedListTest(unittest.TestCase):
def setUp(self):
self.result = []
self.obj = SinglyLinkedList()
def test_get_empty_list(self):
self.result.append(self.obj.get(0))
self.assertEqual(self.result, [
-1,
])
def test_add_head(self):
self.obj.addAtHead(5)
self.result.append(self.obj.get(0))
self.obj.addAtHead(10)
for i in range(2):
self.result.append(self.obj.get(i))
self.assertEqual(self.result, [
5,
10,
5,
])
def test_add_tail(self):
self.obj.addAtTail(5)
self.result.append(self.obj.get(0))
self.obj.addAtHead(10)
self.obj.addAtTail(15)
for i in range(3):
self.result.append(self.obj.get(i))
self.assertEqual(self.result, [
5,
10,
5,
15,
])
def test_add_index(self):
self.obj.addAtIndex(0, 5)
self.result.append(self.obj.get(0))
self.obj.addAtIndex(0, 10)
for i in range(2):
self.result.append(self.obj.get(i))
self.obj.addAtIndex(1, 15)
for i in range(3):
self.result.append(self.obj.get(i))
self.obj.addAtIndex(3, 20)
for i in range(4):
self.result.append(self.obj.get(i))
self.assertEqual(self.result, [5, 10, 5, 10, 15, 5, 10, 15, 5, 20])
def test_delete(self):
for i in range(4):
self.obj.addAtHead(i)
self.obj.deleteAtIndex(0)
for i in range(3):
self.result.append(self.obj.get(i))
self.obj.deleteAtIndex(1)
for i in range(2):
self.result.append(self.obj.get(i))
self.assertEqual(self.result, [2, 1, 0, 2, 0])
def main():
ll1 = SinglyLinkedList()
ll2 = SinglyLinkedList()
for i in xrange(8):
ll1.append(i)
for i in [-1, 0, 2, 7, 8, 9]:
ll2.append(i)
merged_ll_head = merge_linked_lists(ll1.head, ll2.head)
expected = [-1, 0, 0, 1, 2, 2, 3, 4, 5, 6, 7, 7, 8, 9]
for num in expected:
assert num == merged_ll_head.val
merged_ll_head = merged_ll_head.next
ll3 = SinglyLinkedList()
ll4 = SinglyLinkedList()
for i in xrange(8):
ll3.append(i)
for i in [-1, 0, 2, 7, 8, 9]:
ll4.append(i)
merged_ll_head = merge_linked_lists_r(ll3.head, ll4.head)
expected = [-1, 0, 0, 1, 2, 2, 3, 4, 5, 6, 7, 7, 8, 9]
for num in expected:
assert num == merged_ll_head.val
merged_ll_head = merged_ll_head.next
def setUp(self):
self.result = []
self.obj = SinglyLinkedList()
def __init__(self, *args, **kwargs):
super(TestInsert, self).__init__(*args, **kwargs)
self.test_list = []
self.test_SinglyLinkedList = SinglyLinkedList()
class TestInsert(unittest.TestCase):
def __init__(self, *args, **kwargs):
super(TestInsert, self).__init__(*args, **kwargs)
self.test_list = []
self.test_SinglyLinkedList = SinglyLinkedList()
# self.test_list = random.sample(range(0, RANDMAX), 7) # TODO: change this randomizing parameters
def test_InsertAtBeginning_once(self):
test_insert = random.randint(0, RANDMAX)
self.test_list.insert(0, test_insert)
self.test_SinglyLinkedList.insertAtBeginning(test_insert)
self.assertEqual(list(self.test_SinglyLinkedList.toList()),
self.test_list)
def test_InsertAtBeginning_multiple(self):
for _ in range(random.randint(0, RANDMAX // 2)):
test_insert = random.randint(0, RANDMAX)
self.test_list.insert(0, test_insert)
self.test_SinglyLinkedList.insertAtBeginning(test_insert)
self.assertEqual(list(self.test_SinglyLinkedList.toList()),
self.test_list)
def test_insertAtEnd_once(self):
test_insert = random.randint(0, RANDMAX)
self.test_list.append(test_insert)
self.test_SinglyLinkedList.insertAtEnd(test_insert)
self.assertEqual(list(self.test_SinglyLinkedList.toList()),
self.test_list)
def test_insertAtEnd_multiple(self):
for _ in range(random.randint(0, RANDMAX // 2)):
test_insert = random.randint(0, RANDMAX)
self.test_list.append(test_insert)
self.test_SinglyLinkedList.insertAtEnd(test_insert)
self.assertEqual(list(self.test_SinglyLinkedList.toList()),
self.test_list)
def test_insertAt0_once(self):
test_insert = random.randint(0, RANDMAX)
self.test_list.append(test_insert)
self.test_SinglyLinkedList.insertAt(test_insert, 0)
self.assertEqual(list(self.test_SinglyLinkedList.toList()),
self.test_list)
def test_insertAt_warning(self):
test_insert = random.randint(0, RANDMAX)
test_insert_pos = random.randint(1, RANDMAX)
with self.assertWarns(RuntimeWarning):
self.test_SinglyLinkedList.insertAt(test_insert, test_insert_pos)
def test_insertAt_random(self):
for i in range(random.randint(0, RANDMAX // 2)):
test_insert = random.randint(0, RANDMAX)
test_insert_pos = random.randint(0, i)
self.test_list.insert(test_insert_pos, test_insert)
self.test_SinglyLinkedList.insertAt(test_insert, test_insert_pos)
self.assertEqual(list(self.test_SinglyLinkedList.toList()),
self.test_list)
def __init__(self):
self.ins = SinglyLinkedList()
def main():
ll1 = SinglyLinkedList()
ll2 = SinglyLinkedList()
for i in xrange(8):
ll1.append(i)
for i in [-1, 0, 2, 7, 8, 9]:
ll2.append(i)
merged_ll_head = merge_linked_lists(ll1.head, ll2.head)
expected = [-1, 0, 0, 1, 2, 2, 3, 4, 5, 6, 7, 7, 8, 9]
for num in expected:
assert num == merged_ll_head.val
merged_ll_head = merged_ll_head.next
ll3 = SinglyLinkedList()
ll4 = SinglyLinkedList()
for i in xrange(8):
ll3.append(i)
for i in [-1, 0, 2, 7, 8, 9]:
ll4.append(i)
merged_ll_head = merge_linked_lists_r(ll3.head, ll4.head)
expected = [-1, 0, 0, 1, 2, 2, 3, 4, 5, 6, 7, 7, 8, 9]
for num in expected:
assert num == merged_ll_head.val
merged_ll_head = merged_ll_head.next
def __init__(self):
self.new_list = SinglyLinkedList()
def test_unequal(self):
lst1 = SinglyLinkedList(1)
lst2 = SinglyLinkedList(2)
self.assertFalse(are_equal(lst1, lst2))
from LinkedList import SinglyLinkedList ll = SinglyLinkedList() print(ll)
return
current = ll.head
while current:
runner = current
while runner.next:
if runner.next.data == current.data:
runner.next = runner.next.next
else:
runner = runner.next
current = current.next
return ll.head
ll = SinglyLinkedList()
for i in range(0, 99):
ll.append(100 * random.random())
print(ll)
remove_dups(ll)
print(ll)
ll = SinglyLinkedList()
for i in range(0, 99):
ll.append(100 * random.random())
print(ll)
remove_dups_no_cache(ll)
print(ll)
