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()
