def test_pop(self): """ Tests the pop() method """ dll = DoublyLinkedList() # test with no nodes self.assertIsNone(dll.pop()) # test with one node dll.push('node zero') self.assertEqual(dll.length, 1) popped = dll.pop() self.assertEqual(dll.length, 0) self.assertEqual(popped.data, "node zero") # test with two nodes dll.push('node zero') dll.push('node one') self.assertEqual(dll.head.data, 'node zero') self.assertEqual(dll.tail.data, 'node one') self.assertEqual(dll.length, 2) popped = dll.pop() self.assertEqual(popped.data, 'node one') self.assertEqual(dll.length, 1) # test pop prev, next are None self.assertIsNone(popped.prev) self.assertIsNone(popped.next)
def test_unshift(self): """ Tests the unshift(data) method """ # test empty list dll = DoublyLinkedList() self.assertEqual(dll.length, 0) self.assertIsNone(dll.head) self.assertIsNone(dll.tail) dll.unshift('node zero') self.assertEqual(dll.length, 1) self.assertEqual(dll.head.data, 'node zero') # test one node expected_list = ['node zero'] self.assertEqual(dll.to_list(), expected_list) unshifted = dll.unshift('node subzero') self.assertIsInstance(unshifted, DoublyLinkedList) self.assertEqual(dll.length, 2) expected_list = ['node subzero', 'node zero'] self.assertEqual(dll.to_list(), expected_list) # test with two nodes unshifted = dll.unshift('node subsubzero') self.assertIsInstance(unshifted, DoublyLinkedList) self.assertEqual(dll.length, 3) expected_list = ['node subsubzero', 'node subzero', 'node zero'] self.assertEqual(dll.to_list(), expected_list)
def test_insert(self): """ Tests the insert(index, data) method """ dll = DoublyLinkedList() # test out of bounds self.assertIsNone(dll.insert(-1, 'data')) self.assertIsNone(dll.insert(1, 'data')) # test inserting at index zero in open list (should use unshift(data)) dll.insert(0, 'node zero') self.assertEqual(dll.length, 1) self.assertEqual(dll.head.data, 'node zero') dll.clear() dll.push(0) # index 0 dll.push(1) # index 1 dll.push(2) # index 2 # insert at index 1 expected_list = [0, 'insert one', 1, 2] self.assertIsInstance(dll.insert(1, 'insert one'), DoublyLinkedList) self.assertEqual(dll.length, 4) self.assertEqual(dll.to_list(), expected_list) # insert at tail, index 4 expected_list = [0, 'insert one', 1, 2, 'insert tail'] self.assertIsInstance(dll.insert(4, 'insert tail'), DoublyLinkedList) self.assertEqual(dll.length, 5) self.assertEqual(dll.to_list(), expected_list)
def mergeTwoSortedLists(l1, l2): if not l1: return l2 if not l2: return l1 if not l1 and not l2: return None ll = DoublyLinkedList() cur_l1 = l1.head cur_l2 = l2.head index = 0 max_length = l1.length + l2.length while index < max_length: if cur_l1 and cur_l2: if cur_l1.value <= cur_l2.value: ll.addAtIndex(index, cur_l1.value) cur_l1 = cur_l1.next else: ll.addAtIndex(index, cur_l2.value) cur_l2 = cur_l2.next elif cur_l1 and not cur_l2: ll.addAtIndex(index, cur_l1.value) cur_l1 = cur_l1.next elif cur_l2 and not cur_l1: ll.addAtIndex(index, cur_l2.value) cur_l2 = cur_l2.next index += 1 return ll
def test_list_init(self): """ Test new DoublyLinked List initialization """ dll = DoublyLinkedList() self.assertIsInstance(dll, DoublyLinkedList) self.assertEqual(dll.length, 0) self.assertIsNone(dll.head) self.assertIsNone(dll.tail)
def test_shift(self): """ Tests the shift() method """ dll = DoublyLinkedList() # test shifting empty list self.assertIsNone(dll.shift()) # test one node dll.push('node zero') self.assertEqual(dll.length, 1) shifted = dll.shift() self.assertEqual(dll.length, 0) self.assertIsNone(dll.head) self.assertIsNone(dll.tail) self.assertEqual(shifted.data, 'node zero') self.assertIsNone(shifted.next) self.assertIsNone(shifted.prev) # test two nodes dll.push('node one') dll.push('node two') self.assertEqual(dll.length, 2) shifted = dll.shift() self.assertEqual(dll.length, 1) expected_list = ['node two'] self.assertEqual(dll.to_list(), expected_list) self.assertIsNone(shifted.next) self.assertIsNone(shifted.prev) # test three nodes dll = DoublyLinkedList() dll.push('node one') dll.push('node two') dll.push('node three') self.assertEqual(dll.length, 3) shifted = dll.shift() self.assertEqual(dll.length, 2) expected_list = ['node two', 'node three'] self.assertEqual(dll.to_list(), expected_list) self.assertIsNone(shifted.next) self.assertIsNone(shifted.prev)
def test_clear(self): """ Tests the clear() method """ dll = DoublyLinkedList() dll.push('node one') dll.push('node two') dll.push('node three') self.assertEqual(dll.length, 3) self.assertIsInstance(dll.clear(), DoublyLinkedList) self.assertEqual(dll.length, 0) self.assertIsNone(dll.head) self.assertIsNone(dll.tail)
def addingTwoNumbers(l1, l2): l1_values = [] l2_values = [] while l1.head or l2.head: if l1.head: l1_values.append(str(l1.head.value)) l1.head = l1.head.next if l2.head: l2_values.append(str(l2.head.value)) l2.head = l2.head.next sum_result = int("".join(l1_values[::-1])) + int("".join(l2_values[::-1])) sum_result = list(str(sum_result)) ll = DoublyLinkedList() index = 0 for i in range(len(sum_result) - 1, -1, -1): ll.addAtIndex(index, sum_result[i]) index += 1 return ll
def test_get(self): """ Tests the get(index) method """ dll = DoublyLinkedList() dll.push(0) # index 0 dll.push(1) # index 1 dll.push(2) # index 2 dll.push(3) # index 3 dll.push(4) # index 4 dll.push(5) # index 5 self.assertEqual(dll.length, 6) # test out of bounds self.assertIsNone(dll.get(-1)) self.assertIsNone(dll.get(99)) self.assertIsNone(dll.get(6)) self.assertEqual(dll.get(0).data, 0) self.assertEqual(dll.get(3).data, 3) self.assertEqual(dll.get(4).data, 4) self.assertEqual(dll.get(5).data, 5)
def main(): # Start with empty list llist = DoublyLinkedList() # Insert 6. So the list becomes 6->None llist.append(6) # Insert 7 at the beginning. # So linked list becomes 7->6->None llist.push(7) # Insert 1 at the beginning. # So linked list becomes 1->7->6->None llist.push(1) # Insert 4 at the end. # So linked list becomes 1->7->6->4->None llist.append(4) # Insert 8, after 7. # So linked list becomes 1->7->8->6->4->None llist.insert(llist.head.next, 8) print('###################') llist.printList() # So linked list becomes 1->7->8->2->6->4->None llist.insertAt(2, 2) llist.printList() print('###################') llist.delete(llist.head) llist.delete(llist.head.next) llist.delete(llist.head.next) llist.printList() print('###################') llist.deleteAt(2) llist.printList()
def test_push(self): """ Tests the push(data) method """ dll = DoublyLinkedList() dll.push('node zero') self.assertEqual(dll.length, 1) self.assertIsNotNone(dll.head) self.assertIsNotNone(dll.tail) self.assertIsNone(dll.head.next) self.assertIsNone(dll.head.prev) self.assertIsNone(dll.tail.prev) self.assertIsNone(dll.tail.next) self.assertEqual(dll.head.data, 'node zero') self.assertEqual(dll.tail.data, 'node zero') dll.push('node one') self.assertEqual(dll.length, 2) self.assertIsNone(dll.head.prev) self.assertIsNone(dll.tail.next) self.assertEqual(dll.head.data, 'node zero') self.assertEqual(dll.tail.data, 'node one') self.assertEqual(dll.head.next.data, 'node one') self.assertEqual(dll.tail.prev.data, 'node zero')
def test_delete(self): """ tests the delete(index) method """ dll = DoublyLinkedList() # test out of bounds self.assertIsNone(dll.delete(-1)) self.assertIsNone(dll.delete(1)) dll.push(0) # index 0 dll.push(1) # index 1 dll.push(2) # index 2 # test can delete head (index 0) deleted = dll.delete(0) self.assertIsInstance(deleted, Node) self.assertEqual(deleted.data, 0) self.assertEqual(dll.length, 2) # unshift the node back, then test delete at tail (index 2) dll.unshift(0) self.assertEqual(dll.to_list(), [0, 1, 2]) self.assertEqual(dll.length, 3) deleted = dll.delete(dll.length - 1) # index 2 self.assertIsInstance(deleted, Node) self.assertEqual(deleted.data, 2) self.assertEqual(dll.length, 2) # push the node back, then test delete from middle (index 1) dll.push(2) self.assertEqual(dll.to_list(), [0, 1, 2]) self.assertEqual(dll.length, 3) deleted = dll.delete(1) self.assertIsInstance(deleted, Node) self.assertEqual(deleted.data, 1) self.assertEqual(dll.length, 2)
def test_set(self): """ Tests the set(index, data) method """ dll = DoublyLinkedList() # test empty list self.assertIsNone(dll.set(0, 'data')) # test out of bounds self.assertIsNone(dll.set(-1, 'data')) self.assertIsNone(dll.set(1, 'data')) dll.push(0) # index 0 dll.push(1) # index 1 dll.push(2) # index 2 dll.push(3) # index 3 dll.push(4) # index 4 dll.push(5) # index 5 self.assertEqual(dll.length, 6) self.assertIsInstance(dll.set(2, "index 2"), Node) expected_list = [0, 1, 'index 2', 3, 4, 5] self.assertEqual(dll.to_list(), expected_list)
def __init__(self): self._list = DoublyLinkedList()
def __init__(self): self.data = DoublyLinkedList()
l2_values.append(str(l2.head.value)) l2.head = l2.head.next sum_result = int("".join(l1_values[::-1])) + int("".join(l2_values[::-1])) sum_result = list(str(sum_result)) ll = DoublyLinkedList() index = 0 for i in range(len(sum_result) - 1, -1, -1): ll.addAtIndex(index, sum_result[i]) index += 1 return ll if __name__ == "__main__": LL1 = DoublyLinkedList() LL1.addAtHead(2) LL1.addAtTail(4) LL1.addAtTail(9) print(LL1) LL2 = DoublyLinkedList() LL2.addAtHead(5) LL2.addAtTail(6) LL2.addAtTail(4) LL2.addAtTail(9) print(LL2) print(addingTwoNumbers(LL1, LL2)) LL3 = DoublyLinkedList()
from Node import Node from doublyLinkedList import DoublyLinkedList # node1 = Node(1) # node2 = Node(2) dl = DoublyLinkedList() dl.insertAtBeginning(4) dl.insertAtBeginning(5) dl.insertAtEnd(6) dl.insertAtPos(8, 2) dl.printList() # dl.deleteFirstNode() dl.deleteLastNode # dl.insertAtBeginning(7) # dl.insertAtBeginning(9) # dl.insertAtPos(10,3) # dl.insertAtPos(11,0) # dl.deleteFirstNode() # dl.deleteLastNode() dl.deleteFromPos(2) # dl.deleteFromPos(2) # dl.deleteFromPos(3) dl.printList()
def __init__(self, itemLimit): self.itemLimit = itemLimit self.itemCount = 0 self.store = {} self.list = DoublyLinkedList()
def setUp(self): self.list = DoublyLinkedList()
def __init__(self, capacity): self.capacity = capacity self.firstIn = None self.storage = DoublyLinkedList()
def test_to_list(self): """ Tests the to_list() method """ dll = DoublyLinkedList() self.assertEqual(dll.to_list(), [])
def main(): print('###############################') # array declaration arr = [2, 3, 5, 8, 9, 10, 11] # value to search val = 17 print(isPairSum(arr, len(arr), val)) print('###############################') llist = DoublyLinkedList() for item in arr: llist.append(item) pairSum( llist.head, val ) print('###############################') arr = [0, -1, 2, -3, 1] n = len(arr) findTriplets_hash(arr, n) print('###############################') findTriplets(arr, n) print('###############################') nums = [0,0,1,1,1,2,2,3,3,4] k = removeDuplicates( nums ) print(k) print(nums[:k]) nums = [1,1,2] k = removeDuplicates( nums ) print(k) print(nums[:k]) nums = [0,0,1,1,1,2,2,3,3,4] print('######## removeDuplicates2 #######################') k = removeDuplicates2( nums ) print(k) print(nums[:k]) print('###############################') llist = LinkedList() llist.push(20) llist.push(4) llist.push(4) llist.push(20) print( isPalindrome(llist.head) ) print( isPalindrome2(llist.head) ) print('###############################') llist = LinkedList() llist.push(7) llist.push(6) llist.push(5) llist.push(4) llist.push(3) llist.push(2) llist.push(1) llist.printList() print('###############################') reorderList(llist.head) llist.printList() print('###############################') arr = [1,2,3,4,5,6] swap(arr,0,3) print(arr) reverse(arr) print(arr) print('###############################') height = [1,8,6,2,5,4,8,3,7] print(maxArea(height)) print('###############################')
def __init__(self, x): self.queue = DoublyLinkedList()