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