class ReverseVisitor(Visitor):
def __init__(self):
self._list = LinkedList()
def visit(self, obj):
self._list.prepend(obj)
def getList(self):
return self._list
list = property(
fget = lambda self: self.getList())
class StackAsLinkedList(Stack):
"""
Stack implemented using a linked list.
"""
#}@head
#{
# ...
#}@tail
#{
def __init__(self):
"""
(StackAsLinkedList)
Constructs a stack.
"""
super(StackAsLinkedList, self).__init__()
self._list = LinkedList()
def purge(self):
"""
(StackAsLinkedList) -> None
Purges this stack.
"""
self._list.purge()
self._count = 0
#}>a
#{
def push(self, obj):
"""
(StackAsLinkedList, Object) -> None
Pushes the given object on to this stack.
"""
self._list.prepend(obj)
self._count += 1
def pop(self):
"""
(StackAsLinkedList) -> None
Pops the top object off this stack.
"""
if self._count == 0:
raise ContainerEmpty
result = self._list.first
self._list.extract(result)
self._count -= 1
return result
def getTop(self):
"""
(StackAsLinkedList) -> None
Returns the object at the top of this stack.
"""
if self._count == 0:
raise ContainerEmpty
return self._list.first
#}>b
#{
def accept(self, visitor):
"""
(StackAsLinkedList, Visitor) -> None
Makes the given visitor visit all the objects in this stack.
"""
assert isinstance(visitor, Visitor)
ptr = self._list.head
while ptr is not None:
visitor.visit(ptr.datum)
if visitor.isDone:
return
ptr = ptr.next
#}>c
#{
class Iterator(Iterator):
"""
Enumerates the elements of a StackAsLinkedList.
"""
def __init__(self, stack):
"""
(StackAsLinkedList.Iterator, StackAsLinkedList) -> None
Constructs an iterator for the given stack.
"""
super(StackAsLinkedList.Iterator, self).__init__(stack)
self._position = stack._list.head
def next(self):
"""
(StackAsLinkedList.Iterator) -> Object
Returns the next element.
"""
if self._position is None:
raise StopIteration
element = self._position
self._position = self._position.next
return element.datum
def __iter__(self):
"""
(StackAsLinkedList) -> StackAsLinkedList.Iterator
Returns an iterator for this stack.
"""
return self.Iterator(self)
#}>d
def _compareTo(self, obj):
"""
(StackAsLinkedList, StackAsLinkedList) -> int
Compares this stack with the given stack.
"""
assert isinstance(self, obj.__class__)
raise NotImplementedError
@staticmethod
def main(*argv):
"StackAsLinkedList test program."
print StackAsLinkedList.main.__doc__
stack2 = StackAsLinkedList()
Stack.test(stack2)
return 0
class MultisetAsLinkedList(Multiset):
"""
Multiset implemented using a linked list of elements.
"""
#}@head
#{
# ...
#}@tail
#{
def __init__(self, n):
"""
(MultisetAsLinkedList, int) -> None
Constructs a multiset with the given universe size.
"""
super(MultisetAsLinkedList, self).__init__(n)
self._list = LinkedList()
#}>a
def insert(self, item):
"""
(MultisetAsLinkedList, Object) -> None
Inserts the given element into this multiset.
"""
ptr = self._list.head
prevPtr = None
while ptr is not None:
if ptr.datum >= item:
break
prevPtr = ptr
ptr = ptr.__next__
if prevPtr is None:
self._list.prepend(item)
else:
prevPtr.insertAfter(item)
def withdraw(self, item):
"""
(MultisetAsLinkedList, Object) -> None
Withdraws the given element from this multiset.
"""
ptr = self._list.head
while ptr is not None:
if ptr.datum == item:
list.extract(ptr)
return
ptr = ptr.__next__
def __contains__(self, item):
"""
(MultisetAsLinkedList, Object) -> bool
Returns true if the given elements is in this multiset.
"""
ptr = self._list.head
while ptr is not None:
if ptr.datum == item:
return True
ptr = ptr.__next__
return False
def purge(self):
"""
(MultisetAsLinkedList) -> None
Purges this multiset.
"""
self._list = LinkedList()
def getCount(self):
"""
(MultisetAsLinkedList) -> int
Returns the number of elements in this multiset.
"""
result = 0
ptr = self._list.head
while ptr is not None:
result += 1
ptr = ptr.__next__
return result
def accept(self, visitor):
"""
(MultisetAsLinkedList, Visitor) -> None
Makes the given visitor visit all the elements in this multiset.
"""
assert isinstance(visitor, Visitor)
ptr = self._list.head
while ptr is not None:
visitor.visit(ptr.datum)
if visitor.isDone:
return
ptr = ptr.__next__
#{
def __or__(self, set):
"""
(MultisetAsLinkedList, MultisetAsLinkedList) -> MultisetAsLinkedList
Returns the union of this multiset and the given multiset.
"""
assert isinstance(set, MultisetAsLinkedList)
assert self._universeSize == set._universeSize
result = MultisetAsLinkedList(self._universeSize)
p = self._list.head
q = set._list.head
while p is not None and q is not None:
if p.datum <= q.datum:
result._list.append(p.datum)
p = p.__next__
else:
result._list.append(q.datum)
q = q.__next__
while p is not None:
result._list.append(p.datum)
p = p.__next__
while q is not None:
result._list.append(q.datum)
q = q.__next__
return result
#}>b
#{
def __and__(self, set):
"""
(MultisetAsLinkedList, MultisetAsLinkedList) -> MultisetAsLinkedList
Returns the intersection of this multiset and the given multiset.
"""
assert isinstance(set, MultisetAsLinkedList)
assert self._universeSize == set._universeSize
result = MultisetAsLinkedList(self._universeSize)
p = self._list.head
q = set._list.head
while p is not None and q is not None:
diff = p.datum - q.datum
if diff == 0:
result._list.append(p.datum)
if diff <= 0:
p = p.__next__
if diff >= 0:
q = q.__next__
return result
#}>c
def __sub__(self, set):
"""
(MultisetAsLinkedList, MultisetAsLinkedList) -> MultisetAsLinkedList
Returns the difference of this multiset and the given multiset.
"""
assert isinstance(set, MultisetAsLinkedList)
assert self._universeSize == set._universeSize
result = MultisetAsLinkedList(self._universeSize)
p = self._list.head
q = set._list.head
while p is not None and q is not None:
diff = p.datum - q.datum
if diff < 0:
result._list.append(p.datum)
if diff <= 0:
p = p.__next__
if diff >= 0:
q = q.__next__
while p is not None:
result._list.append(p.datum)
p = p.__next__
return result
def __le__(self, set):
"""
(MultisetAsLinkedList, MultisetAsLinkedList) -> bool
Returns true if this multiset is a proper subset of the given multiset.
"""
assert isinstance(set, MultisetAsLinkedList)
assert self._universeSize == set._universeSize
p = self_list.head
q = set._list.head
while p is not None and q is not None:
diff = p.datum - q.datum
if diff == 0:
p = p.__next__
q = q.__next__
elif diff > 0:
q = q.__next__
else:
return False
if p is not None:
return False
else:
return True
def __eq__(self, set):
"""
(MultisetAsLinkedList, MultisetAsLinkedList) -> bool
Returns true if this multiset is equal to the given multiset.
"""
assert isinstance(set, MultisetAsLinkedList)
assert self._universeSize == set._universeSize
p = self._list.head
q = set._list.head
while p is not None and q is not None:
if p.datum != q.datum:
return False
p = p.__next__
q = q.__next__
if p is not None or q is not None:
return False
else:
return True
class Iterator(Iterator):
"""
Enumerates the elements of a MultisetAsLinkedList.
"""
def __init__(self, multiset):
"""
(MultisetAsLinkedList.Iterator, MultisetAsLinkedList) -> None
Constructs an interator for the given multiset.
"""
super(MultisetAsLinkedList.Iterator, self).__init__(multiset)
self._ptr = None
def __next__(self):
"""
(MultisetAsLinkedList.Iterator) -> Object
Returns the next element in the multiset.
"""
if self._ptr is None:
self._ptr = self._container._list.head
else:
self._ptr = self._ptr.__next__
if self._ptr == None:
raise StopIteration
return self._ptr.datum
def __iter__(self):
"""
(MultisetAsLinkedList) -> MultisetAsLinkedList.Iterator
Returns an iterator for this multiset.
"""
return self.Iterator(self)
def _compareTo(self, obj):
"""
(MultisetAsLinkedList, MultisetAsLinkedList) -> int
Compares this multiset with the given multiset.
"""
assert isinstance(self, obj.__class__)
raise NotImplementedError
@staticmethod
def main(*argv):
"MultisetAsLinkedList test program."
print((MultisetAsLinkedList.main.__doc__))
Multiset.test(MultisetAsLinkedList(32), \
MultisetAsLinkedList(32), MultisetAsLinkedList(32))
return 0
class StackAsLinkedList(Stack):
"""
Stack implemented using a linked list.
"""
#}@head
#{
# ...
#}@tail
#{
def __init__(self):
"""
(StackAsLinkedList)
Constructs a stack.
"""
super(StackAsLinkedList, self).__init__()
self._list = LinkedList()
def purge(self):
"""
(StackAsLinkedList) -> None
Purges this stack.
"""
self._list.purge()
self._count = 0
#}>a
#{
def push(self, obj):
"""
(StackAsLinkedList, Object) -> None
Pushes the given object on to this stack.
"""
self._list.prepend(obj)
self._count += 1
def pop(self):
"""
(StackAsLinkedList) -> None
Pops the top object off this stack.
"""
if self._count == 0:
raise ContainerEmpty
result = self._list.first
self._list.extract(result)
self._count -= 1
return result
def getTop(self):
"""
(StackAsLinkedList) -> None
Returns the object at the top of this stack.
"""
if self._count == 0:
raise ContainerEmpty
return self._list.first
#}>b
#{
def accept(self, visitor):
"""
(StackAsLinkedList, Visitor) -> None
Makes the given visitor visit all the objects in this stack.
"""
assert isinstance(visitor, Visitor)
ptr = self._list.head
while ptr is not None:
visitor.visit(ptr.datum)
if visitor.isDone:
return
ptr = ptr.next
#}>c
#{
class Iterator(Iterator):
"""
Enumerates the elements of a StackAsLinkedList.
"""
def __init__(self, stack):
"""
(StackAsLinkedList.Iterator, StackAsLinkedList) -> None
Constructs an iterator for the given stack.
"""
super(StackAsLinkedList.Iterator, self).__init__(
stack)
self._position = stack._list.head
def next(self):
"""
(StackAsLinkedList.Iterator) -> Object
Returns the next element.
"""
if self._position is None:
raise StopIteration
element = self._position
self._position = self._position.next
return element.datum
def __iter__(self):
"""
(StackAsLinkedList) -> StackAsLinkedList.Iterator
Returns an iterator for this stack.
"""
return self.Iterator(self)
#}>d
def _compareTo(self, obj):
"""
(StackAsLinkedList, StackAsLinkedList) -> int
Compares this stack with the given stack.
"""
assert isinstance(self, obj.__class__)
raise NotImplementedError
@staticmethod
def main(*argv):
"StackAsLinkedList test program."
print StackAsLinkedList.main.__doc__
stack2 = StackAsLinkedList()
Stack.test(stack2)
return 0
class MultisetAsLinkedList(Multiset):
"""
Multiset implemented using a linked list of elements.
"""
#}@head
#{
# ...
#}@tail
#{
def __init__(self, n):
"""
(MultisetAsLinkedList, int) -> None
Constructs a multiset with the given universe size.
"""
super(MultisetAsLinkedList, self).__init__(n)
self._list = LinkedList()
#}>a
def insert(self, item):
"""
(MultisetAsLinkedList, Object) -> None
Inserts the given element into this multiset.
"""
ptr = self._list.head
prevPtr = None
while ptr is not None:
if ptr.datum >= item:
break
prevPtr = ptr
ptr = ptr.next
if prevPtr is None:
self._list.prepend(item)
else:
prevPtr.insertAfter(item)
def withdraw(self, item):
"""
(MultisetAsLinkedList, Object) -> None
Withdraws the given element from this multiset.
"""
ptr = self._list.head
while ptr is not None:
if ptr.datum == item:
list.extract(ptr)
return
ptr = ptr.next
def __contains__(self, item):
"""
(MultisetAsLinkedList, Object) -> bool
Returns true if the given elements is in this multiset.
"""
ptr = self._list.head
while ptr is not None:
if ptr.datum == item:
return True
ptr = ptr.next
return False
def purge(self):
"""
(MultisetAsLinkedList) -> None
Purges this multiset.
"""
self._list = LinkedList()
def getCount(self):
"""
(MultisetAsLinkedList) -> int
Returns the number of elements in this multiset.
"""
result = 0
ptr = self._list.head
while ptr is not None:
result += 1
ptr = ptr.next
return result
def accept(self, visitor):
"""
(MultisetAsLinkedList, Visitor) -> None
Makes the given visitor visit all the elements in this multiset.
"""
assert isinstance(visitor, Visitor)
ptr = self._list.head
while ptr is not None:
visitor.visit(ptr.datum)
if visitor.isDone:
return
ptr = ptr.next
#{
def __or__(self, set):
"""
(MultisetAsLinkedList, MultisetAsLinkedList) -> MultisetAsLinkedList
Returns the union of this multiset and the given multiset.
"""
assert isinstance(set, MultisetAsLinkedList)
assert self._universeSize == set._universeSize
result = MultisetAsLinkedList(self._universeSize)
p = self._list.head
q = set._list.head
while p is not None and q is not None:
if p.datum <= q.datum:
result._list.append(p.datum)
p = p.next
else:
result._list.append(q.datum)
q = q.next
while p is not None:
result._list.append(p.datum)
p = p.next
while q is not None:
result._list.append(q.datum)
q = q.next
return result
#}>b
#{
def __and__(self, set):
"""
(MultisetAsLinkedList, MultisetAsLinkedList) -> MultisetAsLinkedList
Returns the intersection of this multiset and the given multiset.
"""
assert isinstance(set, MultisetAsLinkedList)
assert self._universeSize == set._universeSize
result = MultisetAsLinkedList(self._universeSize)
p = self._list.head
q = set._list.head
while p is not None and q is not None:
diff = p.datum - q.datum
if diff == 0:
result._list.append(p.datum)
if diff <= 0:
p = p.next
if diff >= 0:
q = q.next
return result
#}>c
def __sub__(self, set):
"""
(MultisetAsLinkedList, MultisetAsLinkedList) -> MultisetAsLinkedList
Returns the difference of this multiset and the given multiset.
"""
assert isinstance(set, MultisetAsLinkedList)
assert self._universeSize == set._universeSize
result = MultisetAsLinkedList(self._universeSize)
p = self._list.head
q = set._list.head
while p is not None and q is not None:
diff = p.datum - q.datum
if diff < 0:
result._list.append(p.datum)
if diff <= 0:
p = p.next
if diff >= 0:
q = q.next
while p is not None:
result._list.append(p.datum)
p = p.next
return result
def __le__(self, set):
"""
(MultisetAsLinkedList, MultisetAsLinkedList) -> bool
Returns true if this multiset is a proper subset of the given multiset.
"""
assert isinstance(set, MultisetAsLinkedList)
assert self._universeSize == set._universeSize
p = self_list.head
q = set._list.head
while p is not None and q is not None:
diff = p.datum - q.datum
if diff == 0:
p = p.next
q = q.next
elif diff > 0:
q = q.next
else:
return False
if p is not None:
return False
else:
return True
def __eq__(self, set):
"""
(MultisetAsLinkedList, MultisetAsLinkedList) -> bool
Returns true if this multiset is equal to the given multiset.
"""
assert isinstance(set, MultisetAsLinkedList)
assert self._universeSize == set._universeSize
p = self._list.head
q = set._list.head
while p is not None and q is not None:
if p.datum != q.datum:
return False
p = p.next
q = q.next
if p is not None or q is not None:
return False
else:
return True
class Iterator(Iterator):
"""
Enumerates the elements of a MultisetAsLinkedList.
"""
def __init__(self, multiset):
"""
(MultisetAsLinkedList.Iterator, MultisetAsLinkedList) -> None
Constructs an interator for the given multiset.
"""
super(MultisetAsLinkedList.Iterator, self).__init__(multiset)
self._ptr = None
def next(self):
"""
(MultisetAsLinkedList.Iterator) -> Object
Returns the next element in the multiset.
"""
if self._ptr is None:
self._ptr = self._container._list.head
else:
self._ptr = self._ptr.next
if self._ptr == None:
raise StopIteration
return self._ptr.datum
def __iter__(self):
"""
(MultisetAsLinkedList) -> MultisetAsLinkedList.Iterator
Returns an iterator for this multiset.
"""
return self.Iterator(self)
def _compareTo(self, obj):
"""
(MultisetAsLinkedList, MultisetAsLinkedList) -> int
Compares this multiset with the given multiset.
"""
assert isinstance(self, obj.__class__)
raise NotImplementedError
@staticmethod
def main(*argv):
"MultisetAsLinkedList test program."
print MultisetAsLinkedList.main.__doc__
Multiset.test(MultisetAsLinkedList(32), \
MultisetAsLinkedList(32), MultisetAsLinkedList(32))
return 0
