class Deque(Container):
def __init__(self):
self._list = DoublyLinkedList()
def getHead(self):
return self._list.head
def getTail(self):
return self._list.tail
head = property(
fget = lambda self: self.getHead())
tail = property(
fget = lambda self: self.getTail())
def enqueueHead(self, obj):
self._list.prepend(obj)
def dequeueHead(self):
assert not self._list.isEmpty
return self._list.extract(self._list.head.value)
def enqueueTail(self, obj):
self._list.append(obj)
def dequeueTail(self):
assert not self._list.isEmpty
return self._list.extract(self._list.tail.value)
def __iter__(self):
pass
def _compareTo(self, obj):
pass
def purge(self):
self._list.purge()
#override
def getIsEmpty(self):
return self._list.isEmpty
class Deque(Container):
def __init__(self):
self._list = DoublyLinkedList()
def getHead(self):
return self._list.head
def getTail(self):
return self._list.tail
head = property(fget=lambda self: self.getHead())
tail = property(fget=lambda self: self.getTail())
def enqueueHead(self, obj):
self._list.prepend(obj)
def dequeueHead(self):
assert not self._list.isEmpty
return self._list.extract(self._list.head.value)
def enqueueTail(self, obj):
self._list.append(obj)
def dequeueTail(self):
assert not self._list.isEmpty
return self._list.extract(self._list.tail.value)
def __iter__(self):
pass
def _compareTo(self, obj):
pass
def purge(self):
self._list.purge()
#override
def getIsEmpty(self):
return self._list.isEmpty
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 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('###############################')
class TestList(unittest.TestCase):
def setUp(self):
self.l = DoublyLinkedList()
def test_init(self):
self.assertEqual(self.l.head, None)
self.assertEqual(self.l.tail, None)
def test_append(self):
self.l.append(1)
self.assertEqual(self.l.head.value, 1)
self.assertEqual(self.l.tail.value, 1)
self.l.append(2)
self.assertEqual(self.l.head.value, 1)
self.assertEqual(self.l.tail.value, 2)
self.assertEqual(self.l.first.value, 1)
self.assertEqual(self.l.last.value, 2)
def test_prepend(self):
self.l.prepend(1)
self.assertEqual(self.l.head.value, 1)
self.assertEqual(self.l.tail.value, 1)
self.l.prepend(2)
self.assertEqual(self.l.head.value, 2)
self.assertEqual(self.l.tail.value, 1)
self.l.prepend(3)
self.assertEqual(self.l.head.value, 3)
self.assertEqual(self.l.tail.value, 1)
def test_purge(self):
self.l.append(1)
self.l.append(2)
self.l.append(3)
self.assertEqual(self.l.head.value, 1)
self.assertEqual(self.l.tail.value, 3)
self.l.purge()
self.assertEqual(self.l.head, None)
self.assertEqual(self.l.tail, None)
def test_extract(self):
self.l.append(1)
self.l.append(2)
self.l.append(3)
self.l.append(4)
self.l.append(5)
self.assertEqual(self.l.extract(1), 1)
self.assertEqual(self.l.head.value, 2)
self.assertEqual(self.l.extract(10), None)
self.assertEqual(self.l.extract(5), 5)
self.assertEqual(self.l.tail.value, 4)
def test_copy(self):
self.l.append(1)
self.l.append(2)
self.l.append(3)
a = copy(self.l)
self.assertEqual(a.head.value, 1)
self.assertEqual(a.tail.value, 3)
def test_empty(self):
self.assertTrue(self.l.isEmpty)
self.l.append(1)
self.assertFalse(self.l.isEmpty)
self.l.extract(1)
self.assertTrue(self.l.isEmpty)
