def test_reverse():
ll = LinkedList()
for i in range(10):
ll.insert(i)
t.assertEqual(str(ll), '9->8->7->6->5->4->3->2->1->0->')
ll.reverse()
t.assertEqual(str(ll), '0->1->2->3->4->5->6->7->8->9->')
ll.reverse1()
t.assertEqual(str(ll), '9->8->7->6->5->4->3->2->1->0->')
t.assertEqual(str(ll.reverse2()), '0->1->2->3->4->5->6->7->8->9->')
ll = LinkedList()
for i in range(10):
ll.insert(i)
t.assertEqual(str(ll), '9->8->7->6->5->4->3->2->1->0->')
t.assertEqual(str(ll.reverse2()), '0->1->2->3->4->5->6->7->8->9->')
ll = LinkedList()
for i in range(10):
ll.insert(i)
t.assertEqual(str(ll), '9->8->7->6->5->4->3->2->1->0->')
ll.reverse3()
t.assertEqual(str(ll), '0->1->2->3->4->5->6->7->8->9->')
ll.reverse4()
t.assertEqual(str(ll), '9->8->7->6->5->4->3->2->1->0->')
ll = LinkedList()
for i in range(10):
ll.insert(i)
t.assertEqual(str(ll), '9->8->7->6->5->4->3->2->1->0->')
ll.reverse4()
t.assertEqual(str(ll), '0->1->2->3->4->5->6->7->8->9->')
def test_reverse(self):
sl = LinkedList()
sl.append(12)
sl.append("semir")
sl.append(12.123)
sl.reverse()
self.assertEqual(sl.get_items(), [12.123, "semir", 12])
def testReverseListWithOneElement(self):
linked_list = LinkedList()
linked_list.append(1)
linked_list.reverse()
self.assertEqual([1], linked_list.to_list())
def test_12_reverse(self):
sz = 5
llist = LinkedList()
for i in range(sz):
llist.append(i * 2)
for i in range(len(llist), len(llist) + sz):
llist.prepend(i * 3)
llist.reverse()
self.assertEqual("LinkedList[8,6,4,2,0,15,18,21,24,27]", str(llist))
def testReverseListWithMultipleElements(self):
linked_list = LinkedList()
linked_list.append(1)
linked_list.append(2)
linked_list.append(3)
linked_list.append(4)
linked_list.reverse()
self.assertEqual([4, 3, 2, 1], linked_list.to_list())
def testReverse(): my_linked_list = LinkedList() for i in range(0, 10): my_linked_list.append(random.randint(0,9999)) print my_linked_list my_linked_list.reverse() print my_linked_list
def reverseTest():
ll = LinkedList()
for i in range(1, 11):
ll.insert(i)
print("Initial list before reversing.")
printList(ll)
ll.reverse()
print("List after reversing.")
printList(ll)
return ll
def test_reverse_non_empty_list(self):
mylist = LinkedList()
mylist.add_at_the_end(10)
mylist.add_at_the_end(20)
mylist.add_at_the_end(30)
mylist.add_at_the_end(40)
self.assertEqual(mylist.reverse().data, 40)
def testReverse(self): ll = LinkedList() ll.addNode(1) ll.addNode(2) ll.addNode(3) ll.addNode(4) self.assertEqual(str(ll), 'LinkedList [ 1->2->3->4 ]') self.assertEqual(ll.reverse(), 'LinkedList [ 4->3->2->1 ]')
def reverse_list_test(self):
"""Test the the linked list is correctly able to reverse the order of items within itself. Asserts that the list
has the correct ordering of items after being reversed AND after being reversed a second time.
"""
items = range(1, 10) # test list of items ( numbers 1 - 10)
linked_list = LinkedList()
for item in items: # add each test item to linked list
linked_list.add(item)
linked_list.reverse() # reverse order of both lists
items = reversed(items)
for ll_item, item in zip(linked_list.next(), items): # check that each index holds same item
self.assertEqual(ll_item, item)
linked_list.reverse() # reverse linked list again
for ll_item, item in zip(linked_list.next(), range(1, 10)): # check that each index holds same item
self.assertEqual(ll_item, item)
def palindromeReversing(self, l1: LinkedList):
"""
Solves in O(n), O(n)
"""
l2 = l1.reverse()
p1 = l1.head
p2 = l2.head
while p1 and p2:
if p1.data != p2.data:
return False
p1 = p1.next
p2 = p2.next
return True
from LinkedList import LinkedList
if __name__ == "__main__":
list = LinkedList()
list.addLast(10)
list.addLast(20)
list.addLast(30)
list.addLast(40)
list.addLast(50)
list.reverse()
print(list.size())
# # list.removeFirst()
# print(list.size())
print(list.contains(545))
#
# print(list.size())
# list.reverse()
# print(list.toArray())
class LinkedListTests(unittest.TestCase):
def setUp(self):
self.__list = LinkedList()
def test_append(self):
self.__list.append(1)
self.assertEqual(1, len(self.__list))
def test_insert(self):
self.__list.insert(0, 1)
self.__list.insert(0, 1738)
self.assertEqual(1738, self.__list[0])
self.assertEqual(2, len(self.__list))
def test_remove(self):
self.__list.append(1)
self.assertEqual(1, self.__list[0])
self.__list.remove(1)
self.assertEqual(0, len(self.__list))
def test_pop(self):
self.__list.append(1)
self.__list.append(2)
self.__list.append(3)
self.__list.remove(2)
self.assertEqual(3, self.__list[1])
def test_negative_index(self):
self.__list.append(1)
self.__list.append(2)
self.__list.append(3)
self.assertEqual(3, self.__list[-1])
self.assertEqual(2, self.__list[-2])
self.assertEqual(1, self.__list[-3])
def test_set_item(self):
self.__list.append(1)
self.__list[0] = 2
self.assertEqual(2, self.__list[0])
def test_iteration(self):
for i in xrange(10):
self.__list.append(i)
for index, item in enumerate(self.__list):
self.assertEqual(item, self.__list[index])
def test_reverse(self):
self.__list.append(1)
self.__list.append(2)
self.__list.append(3)
self.assertEqual(1, self.__list[0])
self.__list.reverse()
self.assertEqual(3, self.__list[0])
def test_sort(self):
self.__list.append(3)
self.__list.append(1)
self.__list.append(2)
self.assertEqual(3, self.__list[0])
self.__list.sort()
for i in xrange(1, 4):
self.assertEqual(i, self.__list[i - 1])
print("enter song name")
name = input().lower()
LinkedList.append(name)
if command == "prepend":
print("enter song name")
name = input().lower()
LinkedList.prepend(name)
if command == "find":
print("enter song name to find")
name = input().lower()
print(f'Song Found: {LinkedList.find(name)}')
if command == "reverse":
LinkedList.reverse()
if command == "delete":
print("enter song name to delete")
name = input().lower()
if name == LinkedList.tail:
LinkedList.delete_from_tail()
else:
LinkedList.delete(name)
if command == "print":
print("--------------")
LinkedList.printList()
if command == "exit":
def test_reverse_empty_list(self):
mylist = LinkedList()
self.assertEqual(mylist.reverse(), "List is empty, nothing to reverse")
class TestLinkedList(unittest.TestCase):
def setUp(self):
self.mylist = LinkedList()
self.mylist2 = LinkedList(Node(5))
def test_init(self):
self.assertEqual(self.mylist.getFront(), None)
self.assertEqual(self.mylist.getBack(), None)
self.assertEqual(len(self.mylist), 0)
self.assertEqual(self.mylist2.getFront().getValue(), 5)
self.assertEqual(self.mylist2.getBack().getValue(), 5)
self.assertEqual(len(self.mylist2), 1)
def test_iter(self):
self.assertEqual(len(list(self.mylist)), 0)
l2 = list(self.mylist2)
self.assertEqual(len(l2), 1)
self.assertEqual(l2[0].getValue(), 5)
def test_insert_delete(self):
self.mylist.pushBack(Node(1))
self.assertEqual(self.mylist.getFront().getValue(), 1)
self.assertEqual(self.mylist.getBack().getValue(), 1)
self.assertEqual(len(self.mylist), 1)
self.mylist.popBack()
self.assertEqual(self.mylist.getFront(), None)
self.assertEqual(self.mylist.getBack(), None)
self.assertEqual(len(self.mylist), 0)
self.mylist.pushFront(Node(1))
self.assertEqual(self.mylist.getFront().getValue(), 1)
self.assertEqual(self.mylist.getBack().getValue(), 1)
self.assertEqual(len(self.mylist), 1)
self.mylist.popFront()
self.assertEqual(self.mylist.getFront(), None)
self.assertEqual(self.mylist.getBack(), None)
self.assertEqual(len(self.mylist), 0)
for i in range(3):
self.mylist.insert(Node(i))
self.assertEqual(len(self.mylist), 3)
e3 = self.mylist.getBack()
self.assertEqual(e3.getValue(), 0)
for i in range(3):
self.mylist.insert(Node(i), e3)
self.assertEqual(len(self.mylist), 6)
self.mylist.remove(e3)
self.assertEqual(len(self.mylist), 5)
self.assertEqual(str(self.mylist), str([2, 1, 2, 1, 0]))
def test_reverse(self):
for i in range(3):
self.mylist.pushBack(Node(i))
print(self.mylist)
self.assertEqual(len(self.mylist), 3)
rev = self.mylist.reverse()
self.assertEqual(str(rev), str([2, 1, 0]))
from LinkedList import LinkedList
from Stack import Stack
# 1. Use your linked list code and add a method called reverse() that will reverse the linked list. You can start with making a reversed copy and build up to reversing the linked list "in place" as a strecth goal. For example if your linked list is 3->5->6 your function will return 6->5->3
reverseList = LinkedList()
# add items to the list
reverseList.append(3)
reverseList.append(5)
reverseList.append(6)
# print the lsit
print("List")
reverseList.printList()
# reverse the items in the list
reverseList.reverse()
print("Reversed List")
reverseList.printList()
# add a number to the beginning of the reversd list
print("Prepend 7 to reversed list")
reverseList.prepend(7)
reverseList.printList()
print()
# 2. Write a function called reverse_num() that will reverse an integer using a stack. For example if the integer is 123 your function will return 321, make sure to use a stack!
def reverse_num(num):
"""Reverses an integer"""
# reverse an integer using a stack
stack = Stack()
from BSTree import BinarySearchTree as BST
from LinkedList import LinkedList as LL
tree = BST()
tree.insert(50).insert(30).insert(20).insert(40).insert(10).insert(70).insert(
60).insert(80).insert(90)
print(tree.preOrder.__doc__)
tree.preOrder()
linkedlist = LL()
linkedlist.append(12).append(20).append(3).append(7).append(19).append(
35).append(1).append(44)
print(linkedlist)
linkedlist.reverse()
print(linkedlist)
def test_reverse_one_element_list(self):
mylist = LinkedList()
mylist.add_at_the_end(10)
self.assertEqual(mylist.reverse().data, 10)
ll2 = ll.copy()
print(ll == ll2)
print(ll.contentEquals(ll2))
print(ll.dataEquals(ll2))
del ll2
ll2 = copy.deepcopy(ll)
print(ll == ll2)
print(ll.contentEquals(ll2))
print(ll.dataEquals(ll2))
del ll2
# reverse
ll.add(3, 9)
print(ll)
print(reversed(ll))
ll.reverse()
print(ll)
# iterable by for loop
for node in ll:
e = ', ' if node.next != None else ''
print(node.__repr__(), end=e)
print()
# supports indexing and multiplication too
ll = ll * 3
print(ll)
print(ll[1:8])
print(ll[1:8:2])
print(ll[::-2])
def test_reverse(self):
l = LinkedList(1, 2, 3, 'Hello', 'World')
self.assertTrue(l.reverse().equals(
LinkedList('World', 'Hello', 3, 2, 1)))
def testReverseEmptyList(self):
linked_list = LinkedList()
linked_list.reverse()
self.assertEqual([], linked_list.to_list())
def is_palindrome(data):
ll = LinkedList()
ll.insert_multiple(*data)
return str(ll) == str(ll.reverse())
def create_list():
ll = LinkedList()
for i in range(10):
ll.insert(i)
ll.reverse()
return ll
