def __init__(self, n):
"""
(MultisetAsLinkedList, int) -> None
Constructs a multiset with the given universe size.
"""
super(MultisetAsLinkedList, self).__init__(n)
self._list = LinkedList()
def purge(self):
"""
(BinomialQueue) -> None
Purges this binomial queue.
"""
self._treeList = LinkedList()
self._count = 0
def __init__(self):
"""
(OrderedListAsLinkedList) -> None
Constructs an ordered list.
"""
super(OrderedListAsLinkedList, self).__init__()
self._linkedList = LinkedList()
def purge(self):
"""
(OrderedListAsLinkedList) -> None
Purges this ordered list.
"""
self._linkedList = LinkedList()
self._count = 0
def merge(self, queue):
"""
(BinomialQueue, BinomialQueue) -> None
Merges the contents of the given binomial queue
with this binomial queue.
"""
oldList = self._treeList
self._treeList = LinkedList()
self._count = 0
p = oldList.head
q = queue._treeList.head
carry = None
i = 0
while p is not None or q is not None \
or carry is not None:
a = None
if p is not None:
tree = p.datum
if tree.degree == i:
a = tree
p = p.__next__
b = None
if q is not None:
tree = q.datum
if tree.degree == i:
b = tree
q = q.__next__
(sum, carry) = BinomialQueue.fullAdder(a, b, carry)
if sum is not None:
self.addTree(sum)
i += 1
queue.purge()
def __init__(self):
"""
(QueueAsLinkedList) -> None
Constructs a queue.
"""
super(QueueAsLinkedList, self).__init__()
self._list = LinkedList()
def __init__(self):
"""
(StackAsLinkedList)
Constructs a stack.
"""
super(StackAsLinkedList, self).__init__()
self._list = LinkedList()
def __init__(self, key):
"""
(GeneralTree, Object) -> None
Constructs a general tree with the given object at its root.
"""
super(GeneralTree, self).__init__()
self._key = key
self._degree = 0
self._list = LinkedList()
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())
def __init__(self, *args):
"""
(BinomialQueue, ...) -> None
Constructor.
"""
super(BinomialQueue, self).__init__()
self._treeList = LinkedList()
if len(args) == 0:
pass
elif len(args) == 1:
assert isinstance(args[0], self.BinomialTree)
self._treeList.append(args[0])
else:
raise ValueError
def __init__(self):
"""
(QueueAsLinkedList) -> None
Constructs a queue.
"""
super(QueueAsLinkedList, self).__init__()
self._list = LinkedList()
def __init__(self, n):
"""
(MultisetAsLinkedList, int) -> None
Constructs a multiset with the given universe size.
"""
super(MultisetAsLinkedList, self).__init__(n)
self._list = LinkedList()
def merge(self, queue):
"""
(BinomialQueue, BinomialQueue) -> None
Merges the contents of the given binomial queue
with this binomial queue.
"""
oldList = self._treeList
self._treeList = LinkedList()
self._count = 0
p = oldList.head
q = queue._treeList.head
carry = None
i = 0
while p is not None or q is not None \
or carry is not None:
a = None
if p is not None:
tree = p.datum
if tree.degree == i:
a = tree
p = p.next
b = None
if q is not None:
tree = q.datum
if tree.degree == i:
b = tree
q = q.next
(sum, carry) = BinomialQueue.fullAdder(a, b, carry)
if sum is not None:
self.addTree(sum)
i += 1
queue.purge()
def purge(self):
"""
(BinomialQueue) -> None
Purges this binomial queue.
"""
self._treeList = LinkedList()
self._count = 0
def __init__(self):
"""
(OrderedListAsLinkedList) -> None
Constructs an ordered list.
"""
super(OrderedListAsLinkedList, self).__init__()
self._linkedList = LinkedList()
def purge(self):
"""
(OrderedListAsLinkedList) -> None
Purges this ordered list.
"""
self._linkedList = LinkedList()
self._count = 0
def __init__(self):
"""
(StackAsLinkedList)
Constructs a stack.
"""
super(StackAsLinkedList, self).__init__()
self._list = LinkedList()
def __init__(self, size):
"""
(GraphAsLists, int) -> None
Constructs a graph with the given maximum number of vertices.
"""
super(GraphAsLists, self).__init__(size)
self._adjacencyList = Array(size)
for i in range(size):
self._adjacencyList[i] = LinkedList()
def __init__(self, key):
"""
(GeneralTree, Object) -> None
Constructs a general tree with the given object at its root.
"""
super(GeneralTree, self).__init__()
self._key = key
self._degree = 0
self._list = LinkedList()
def __init__(self, length):
"""
(ChainedHashTable, int) -> None
Constructs a chained hash table with the given length.
"""
super(ChainedHashTable, self).__init__()
self._array = Array(length)
for i in xrange(len(self._array)):
self._array[i] = LinkedList()
def __init__(self, numberOfRows, numberOfColumns):
"""
(SparseMatrixAsLinkedList, int, int) -> None
Constructs a sparse matrix with the given number of rows and columns.
"""
super(SparseMatrixAsLinkedList, self).__init__(numberOfRows,
numberOfColumns)
self._lists = Array(numberOfRows)
for i in xrange(numberOfRows):
self._lists[i] = LinkedList()
def __init__(self, *args):
"""
(BinomialQueue, ...) -> None
Constructor.
"""
super(BinomialQueue, self).__init__()
self._treeList = LinkedList()
if len(args) == 0:
pass
elif len(args) == 1:
assert isinstance(args[0], self.BinomialTree)
self._treeList.append(args[0])
else:
raise ValueError
class QueueAsLinkedList(Queue):
"""
Queue implemented using a linked list.
"""
#}@head
#{
# ...
#}@tail
#{
def __init__(self):
"""
(QueueAsLinkedList) -> None
Constructs a queue.
"""
super(QueueAsLinkedList, self).__init__()
self._list = LinkedList()
def purge(self):
"""
(QueueAsLinkedList) -> None
Purges this queue.
"""
self._list.purge()
self._count = 0
#}>a
#{
def getHead(self):
"""
(QueueAsLinkedList) -> Object
Returns the object at the head of this queue.
"""
if self._count == 0:
raise ContainerEmpty
return self._list.first
def enqueue(self, obj):
"""
(QueueAsLinkedList, Object) -> None
Enqueues the given object to the tail of this queue.
"""
self._list.append(obj)
self._count += 1
def dequeue(self):
"""
(QueueAsLinkedList) -> Object
Dequeues the object at the head of this queue.
"""
if self._count == 0:
raise ContainerEmpty
result = self._list.first
self._list.extract(result)
self._count -= 1
return result
#}>b
def accept(self, visitor):
"""
(QueueAsLinkedList, Visitor) -> None
Makes the given visitor visit all the objects in this queue.
"""
assert isinstance(visitor, Visitor)
ptr = self._list.head
while ptr is not None:
visitor.visit(ptr.datum)
if visitor.isDone:
return
ptr = ptr.next
class Iterator(Iterator):
"""
Enumerates the elements of a QueueAsLinkedList.
"""
def __init__(self, queue):
"""
(QueueAsLinkedList.Iterator, QueueAsLinkedList) -> None
Constructs an iterator for the given queue.
"""
super(QueueAsLinkedList.Iterator).__init__(queue)
self._position = None
def next(self):
"""
(QueueAsLinkedList.Iterator) -> Object
Returns the next element.
"""
if self._position is None:
self._position = self._container._list.head
else:
self._position = self._position.next
if self._position is None:
raise StopIteration
return self._position.datum
def __iter__(self):
"""
(QueueAsLinkedList) -> QueueAsLinkedList.Iterator
Returns an iterator for this queue.
"""
return self.Iterator(self)
def _compareTo(self, obj):
"""
(QueueAsLinkedList, QueueAsLinkedList) -> int
Comparse this queue with the given queue.
"""
assert isinstance(self, obj.__class__)
raise NotImplementedError
def main(*argv):
"QueueAsLinkedList test program."
print QueueAsLinkedList.main.__doc__
queue2 = QueueAsLinkedList()
Queue.test(queue2)
return 0
main = staticmethod(main)
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
def purge(self):
"""
(MultisetAsLinkedList) -> None
Purges this multiset.
"""
self._list = LinkedList()
class BinomialQueue(MergeablePriorityQueue):
"""
Mergeable priority queue implemented as a binomial queue.
"""
#}@head
#{
# ...
#}@tail
#{
def __init__(self, *args):
"""
(BinomialQueue, ...) -> None
Constructor.
"""
super(BinomialQueue, self).__init__()
self._treeList = LinkedList()
if len(args) == 0:
pass
elif len(args) == 1:
assert isinstance(args[0], self.BinomialTree)
self._treeList.append(args[0])
else:
raise ValueError
#}>a
#{
def addTree(self, tree):
"""
(BinomialQueue, BinomialQueue.BinomialTree) -> None
Adds the given binomial tree to this binomial queue.
"""
self._treeList.append(tree)
self._count += tree.count
def removeTree(self, tree):
"""
(BinomialQueue, BinomialQueue.BinomialTree) -> None
Removes the given binomial tree from this binomial queue.
"""
self._treeList.extract(tree)
self._count -= tree.count
#}>b
def purge(self):
"""
(BinomialQueue) -> None
Purges this binomial queue.
"""
self._treeList = LinkedList()
self._count = 0
def accept(self, visitor):
"""
(BinomialQueue, Visitor) -> None
Makes the given visitor visit the elements of this binomial queue.
"""
assert isinstance(visitor, Visitor)
ptr = self._treeList.head
while ptr is not None:
tree = ptr.datum
tree.depthFirstTraversal(PreOrder(visitor))
ptr = ptr.next
#{
def getMinTree(self):
"""
(BinomialQueue) -> BinomialQueue.BinomialTree
Returns the binomial tree in this binomial queue
with the smallest root.
"""
minTree = None
ptr = self._treeList.head
while ptr is not None:
tree = ptr.datum
if minTree is None or tree.key < minTree.key:
minTree = tree
ptr = ptr.next
return minTree
minTree = property(
fget = lambda self: self.getMinTree())
def getMin(self):
"""
(BinomialQueue) -> Object
Returns the object in this binomial queue with the smallest value.
"""
if self._count == 0:
raise ContainerEmpty
return self.minTree.key
#}>c
#{
def merge(self, queue):
"""
(BinomialQueue, BinomialQueue) -> None
Merges the contents of the given binomial queue
with this binomial queue.
"""
oldList = self._treeList
self._treeList = LinkedList()
self._count = 0
p = oldList.head
q = queue._treeList.head
carry = None
i = 0
while p is not None or q is not None \
or carry is not None:
a = None
if p is not None:
tree = p.datum
if tree.degree == i:
a = tree
p = p.next
b = None
if q is not None:
tree = q.datum
if tree.degree == i:
b = tree
q = q.next
(sum, carry) = BinomialQueue.fullAdder(a, b, carry)
if sum is not None:
self.addTree(sum)
i += 1
queue.purge()
#}>d
#{
@staticmethod
def fullAdder(a, b, c):
"""
(BinomialTree, BinomialTree, BinomialTree) ->
(BinomialTree, BinomialTree)
Returns the (sum, carry) of the given binomial trees.
"""
if a is None:
if b is None:
if c is None:
return (None, None)
else:
return (c, None)
else:
if c is None:
return (b, None)
else:
return (None, b.add(c))
else:
if b is None:
if c is None:
return (a, None)
else:
return (None, a.add(c))
else:
if c is None:
return (None, a.add(b))
else:
return (c, a.add(b))
#}>e
#{
def enqueue(self, obj):
"""
(BinomialQueue, Object) -> None
Enqueues the given object in this binomial queue.
"""
self.merge(BinomialQueue(
BinomialQueue.BinomialTree(obj)))
#}>f
#{
def dequeueMin(self):
"""
(BinomialQueue) -> Object
Dequeues and returns the object in this binomial queue
with the smallest value.
"""
if self._count == 0:
raise ContainerEmpty
minTree = self.minTree
self.removeTree(minTree)
queue = BinomialQueue()
while minTree.degree > 0:
child = minTree.getSubtree(0)
minTree.detachSubtree(child)
queue.addTree(child)
self.merge(queue)
return minTree.key
#}>g
def __str__(self):
"""
(BinomialQueue) -> str
Returns a string representation of this binomial queue.
"""
result = self.__class__.__name__ + " {\n"
ptr = self._treeList.head
while ptr is not None:
result = result + str(ptr.datum) + "\n"
ptr = ptr.next
result = result + "}"
return result
#{
class BinomialTree(GeneralTree):
"""
A binomial tree implemented as a general tree.
"""
#}@head
#{
# ...
#}@tail
#{
def __init__(self, key):
"""
(BinomialQueue.BinomialTree, Object) -> None
Constructor.
"""
super(BinomialQueue.BinomialTree, self).__init__(key)
#}>h
def getCount(self):
"""
(BinomialQueue.BinomialTree) -> int
Returns the number of objects in this binomial tree.
"""
return 1 << self._degree
def swapContentsWith(self, tree):
"""
(BinomialQueue.BinomialTree, BinomialQueue.BinomialTree) -> None
Swaps the contents of this binomial tree
with the given binomial tree.
"""
tmp = self._key
self._key = tree._key
tree._key = tmp
tmp = self._list
self._list = tree._list
tree._list = tmp
tmp = self._degree
self._degree = tree._degree
tree._degree = tmp
#{
def add(self, tree):
"""
(BinomialQueue.BinomialTree, BinomialQueue.BinomialTree) ->
BinomialQueue.BinomialTree
Adds this binomail tree and the given binomial tree.
"""
if self._degree != tree._degree:
raise ValueError
if self._key > tree._key:
self.swapContentsWith(tree)
self.attachSubtree(tree)
return self
#}>i
def _compareTo(self, obj):
"""
(BinomialQueue, BinomialQueue) -> int
Compares this binomial queue with the given binomial queue.
"""
assert isinstance(self, obj.__class__)
raise NotImplementedError
def __iter__(self):
"""
(BinomialQueue) -> iterator
Returns an iterator that enumerates the elements of this binomial queue.
"""
raise NotImplementedError
@staticmethod
def main(*argv):
"BinomialQueue test program."
print BinomialQueue.main.__doc__
pqueue = BinomialQueue()
PriorityQueue.test(pqueue)
return 0
class GeneralTree(Tree):
"""
A general tree implemented using a linked list of subtrees.
"""
#}@head
#{
# ...
#}@tail
#{
def __init__(self, key):
"""
(GeneralTree, Object) -> None
Constructs a general tree with the given object at its root.
"""
super(GeneralTree, self).__init__()
self._key = key
self._degree = 0
self._list = LinkedList()
def purge(self):
"""
(GeneralTree) -> None
Purges this general tree.
"""
self._list.purge()
self._degree = 0
#}>a
def getIsEmpty(self):
"""
(GeneralTree) -> bool
Returns false always.
"""
return False
def getIsLeaf(self):
"""
(GeneralTree) -> bool
Returns true if this general tree is a leaf.
"""
return self._degree == 0
def getDegree(self):
"""
(GeneralTree) -> int
Returns the degree of this general tree node.
"""
return self._degree
#{
def getKey(self):
"""
(GeneralTree) -> Object
Returns the key in this general tree node.
"""
return self._key
def getSubtree(self, i):
"""
(GeneralTree) -> Object
Returns the specified subtree of this general tree node.
"""
if i < 0 or i >= self._degree:
raise IndexError
ptr = self._list.head
for j in xrange(i):
ptr = ptr.next
return ptr.datum
def attachSubtree(self, t):
"""
(GeneralTree, GeneralTree) -> None
Attaches the given general tree as a subtree
of this general tree node.
"""
self._list.append(t)
self._degree += 1
def detachSubtree(self, t):
"""
(GeneralTree, GeneralTree) -> GeneralTree
Detaches and returns specified general tree
from this general tree node.
"""
self._list.extract(t)
self._degree -= 1
return t
#}>b
def _compareTo(self, obj):
"""
(GeneralTree, GeneralTree) -> int
Compares this general tree with the given general tree.
"""
assert isinstance(self, obj.__class__)
raise NotImplementedError
@staticmethod
def main(*argv):
"GeneralTree test program."
print GeneralTree.main.__doc__
gt = GeneralTree('A')
gt.attachSubtree(GeneralTree('B'))
gt.attachSubtree(GeneralTree('C'))
gt.attachSubtree(GeneralTree('D'))
gt.attachSubtree(GeneralTree('E'))
Tree.test(gt)
return 0
class GeneralTree(Tree):
"""
A general tree implemented using a linked list of subtrees.
"""
#}@head
#{
# ...
#}@tail
#{
def __init__(self, key):
"""
(GeneralTree, Object) -> None
Constructs a general tree with the given object at its root.
"""
super(GeneralTree, self).__init__()
self._key = key
self._degree = 0
self._list = LinkedList()
def purge(self):
"""
(GeneralTree) -> None
Purges this general tree.
"""
self._list.purge()
self._degree = 0
#}>a
def getIsEmpty(self):
"""
(GeneralTree) -> bool
Returns false always.
"""
return False
def getIsLeaf(self):
"""
(GeneralTree) -> bool
Returns true if this general tree is a leaf.
"""
return self._degree == 0
def getDegree(self):
"""
(GeneralTree) -> int
Returns the degree of this general tree node.
"""
return self._degree
#{
def getKey(self):
"""
(GeneralTree) -> Object
Returns the key in this general tree node.
"""
return self._key
def getSubtree(self, i):
"""
(GeneralTree) -> Object
Returns the specified subtree of this general tree node.
"""
if i < 0 or i >= self._degree:
raise IndexError
ptr = self._list.head
for j in xrange(i):
ptr = ptr.next
return ptr.datum
def attachSubtree(self, t):
"""
(GeneralTree, GeneralTree) -> None
Attaches the given general tree as a subtree
of this general tree node.
"""
self._list.append(t)
self._degree += 1
def detachSubtree(self, t):
"""
(GeneralTree, GeneralTree) -> GeneralTree
Detaches and returns specified general tree
from this general tree node.
"""
self._list.extract(t)
self._degree -= 1
return t
#}>b
def _compareTo(self, obj):
"""
(GeneralTree, GeneralTree) -> int
Compares this general tree with the given general tree.
"""
assert isinstance(self, obj.__class__)
raise NotImplementedError
@staticmethod
def main(*argv):
"GeneralTree test program."
print GeneralTree.main.__doc__
gt = GeneralTree('A')
gt.attachSubtree(GeneralTree('B'))
gt.attachSubtree(GeneralTree('C'))
gt.attachSubtree(GeneralTree('D'))
gt.attachSubtree(GeneralTree('E'))
Tree.test(gt)
return 0
def __init__(self): self._list = LinkedList()
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 OrderedListAsLinkedList(OrderedList):
"""
Ordered list implemented using a linked list.
"""
#}@head
#{
# ...
#}@tail
#{
def __init__(self):
"""
(OrderedListAsLinkedList) -> None
Constructs an ordered list.
"""
super(OrderedListAsLinkedList, self).__init__()
self._linkedList = LinkedList()
#}>a
#{
def insert(self, obj):
"""
(OrderedListAsLinkedList, Object) -> None
Inserts the given object at the end of this list.
"""
self._linkedList.append(obj)
self._count += 1
def __getitem__(self, offset):
"""
(OrderedListAsLinkedList, int) -> Object
Returns the object in this list at the given offset.
"""
if offset < 0 or offset >= self._count:
raise IndexError
ptr = self._linkedList.head
i = 0
while i < offset and ptr is not None:
ptr = ptr.next
i += 1
return ptr.datum
#}>b
def purge(self):
"""
(OrderedListAsLinkedList) -> None
Purges this ordered list.
"""
self._linkedList = LinkedList()
self._count = 0
def accept(self, visitor):
"""
(OrderedListAsLinkedList, Visitor) -> None
Makes the given visitor visit all the objects in this ordered list.
"""
assert isinstance(visitor, Visitor)
ptr = self._linkedList.head
while ptr is not None:
visitor.visit(ptr.datum)
if visitor.isDone:
return
ptr = ptr.next
#{
def __contains__(self, obj):
"""
(OrderedListAsLinkedList, Object) -> bool
Returns true if the given object instance is in this ordered list.
"""
ptr = self._linkedList.head
while ptr is not None:
if ptr.datum is obj:
return True
ptr = ptr.next
return False
def find(self, arg):
"""
(OrderedListAsLinkedList, Object) -> Object
Finds an object in this ordered list that equals the given object.
"""
ptr = self._linkedList.head
while ptr is not None:
obj = ptr.datum
if obj == arg:
return obj
ptr = ptr.next
return None
#}>c
#{
def withdraw(self, obj):
"""
(OrderedListAsLinkedList, Object) -> None
Withdraws the given object instance from this ordered list.
"""
if self._count == 0:
raise ContainerEmpty
self._linkedList.extract(obj)
self._count -= 1
#}>d
#{
def findPosition(self, obj):
"""
(OrderedListAsLinkedList, Object) -> OrderedListAsLinkedList.Cursor
Finds the position of an object in this list
that equals the given object and returns a cursor
that refers to that object.
"""
ptr = self._linkedList.head
while ptr is not None:
if ptr.datum == obj:
break
ptr = ptr.next
return self.Cursor(self, ptr)
#}>e
#{
class Cursor(Cursor):
"""
A cursor that refers to an object in an ordered list.
"""
#}@head
#{
# ...
#}@tail
#{
def __init__(self, list, element):
"""
(OrderedListAsLinkedList.Cursor, OrderedListAsLinkedList,
LinkedList.Element) -> None
Constructs a cursor that refers to the object
in the given element of the given list.
"""
super(OrderedListAsLinkedList.Cursor, self) \
.__init__(list)
self._element = element
def getDatum(self):
"""
(OrderedListAsLinkedList.Cursor) -> Object
Returns the object to which this cursor refers.
"""
return self._element.datum
#}>h
#{
def insertAfter(self, obj):
"""
(OrderedListAsLinkedList.Cursor, Object) -> None
Inserts the given object into the list
after the object to which this cursor refers.
"""
self._element.insertAfter(obj)
self._list._count += 1
#}>f
def insertBefore(self, obj):
"""
(OrderedListAsLinkedList.Cursor, Object) -> None
Inserts the given object into the list
before the object to which this cursor refers.
"""
self._element.insertBefore(obj)
self._list._count += 1
#{
def withdraw(self):
"""
(OrderedListAsLinkedList.Cursor) -> None
Withdraws from the list the object to which this cursor refers.
"""
self._list._linkedList.extract(self._element.datum)
self._list._count -= 1
#}>g
class Iterator(Iterator):
"""
Enumerates the items in an ordered list.
"""
def __init__(self, list):
"""
(OrderedListAsLinkedList.Iterator, OrderedListAsLinkedList) -> None
Constructs an iterator for the given list.
"""
super(OrderedListAsLinkedList.Iterator, self).__init__(list)
self._element = None
def next(self):
"""
(OrderedListAsLinkedList.Iterator) -> Object
Returns the next element.
"""
if self._element is None:
self._element = self._container._linkedList.head
else:
self._element = self._element.next
if self._element is None:
raise StopIteration
return self._element.datum
def __iter__(self):
"""
(OrderedListAsLinkedList) -> OrderedListAsLinkedList.Iterator
Returns an iterator for this ordered list.
"""
return self.Iterator(self)
def _compareTo(self, obj):
"""
(OrderedListAsLinkedList, OrderedListAsLinkedList) -> int
Compares this ordered list with the given ordered list.
"""
assert isinstance(self, obj.__class__)
raise NotImplementedError
def main(*argv):
"OrderedListAsLinkedList test program."
print OrderedListAsLinkedList.main.__doc__
list = OrderedListAsLinkedList()
OrderedList.test(list)
return 0
main = staticmethod(main)
def purge(self):
"""
(MultisetAsLinkedList) -> None
Purges this multiset.
"""
self._list = LinkedList()
class OrderedListAsLinkedList(OrderedList):
"""
Ordered list implemented using a linked list.
"""
#}@head
#{
# ...
#}@tail
#{
def __init__(self):
"""
(OrderedListAsLinkedList) -> None
Constructs an ordered list.
"""
super(OrderedListAsLinkedList, self).__init__()
self._linkedList = LinkedList()
#}>a
#{
def insert(self, obj):
"""
(OrderedListAsLinkedList, Object) -> None
Inserts the given object at the end of this list.
"""
self._linkedList.append(obj)
self._count += 1
def __getitem__(self, offset):
"""
(OrderedListAsLinkedList, int) -> Object
Returns the object in this list at the given offset.
"""
if offset < 0 or offset >= self._count:
raise IndexError
ptr = self._linkedList.head
i = 0
while i < offset and ptr is not None:
ptr = ptr.next
i += 1
return ptr.datum
#}>b
def purge(self):
"""
(OrderedListAsLinkedList) -> None
Purges this ordered list.
"""
self._linkedList = LinkedList()
self._count = 0
def accept(self, visitor):
"""
(OrderedListAsLinkedList, Visitor) -> None
Makes the given visitor visit all the objects in this ordered list.
"""
assert isinstance(visitor, Visitor)
ptr = self._linkedList.head
while ptr is not None:
visitor.visit(ptr.datum)
if visitor.isDone:
return
ptr = ptr.next
#{
def __contains__(self, obj):
"""
(OrderedListAsLinkedList, Object) -> bool
Returns true if the given object instance is in this ordered list.
"""
ptr = self._linkedList.head
while ptr is not None:
if ptr.datum is obj:
return True
ptr = ptr.next
return False
def find(self, arg):
"""
(OrderedListAsLinkedList, Object) -> Object
Finds an object in this ordered list that equals the given object.
"""
ptr = self._linkedList.head
while ptr is not None:
obj = ptr.datum
if obj == arg:
return obj
ptr = ptr.next
return None
#}>c
#{
def withdraw(self, obj):
"""
(OrderedListAsLinkedList, Object) -> None
Withdraws the given object instance from this ordered list.
"""
if self._count == 0:
raise ContainerEmpty
self._linkedList.extract(obj)
self._count -= 1
#}>d
#{
def findPosition(self, obj):
"""
(OrderedListAsLinkedList, Object) -> OrderedListAsLinkedList.Cursor
Finds the position of an object in this list
that equals the given object and returns a cursor
that refers to that object.
"""
ptr = self._linkedList.head
while ptr is not None:
if ptr.datum == obj:
break
ptr = ptr.next
return self.Cursor(self, ptr)
#}>e
#{
class Cursor(Cursor):
"""
A cursor that refers to an object in an ordered list.
"""
#}@head
#{
# ...
#}@tail
#{
def __init__(self, list, element):
"""
(OrderedListAsLinkedList.Cursor, OrderedListAsLinkedList,
LinkedList.Element) -> None
Constructs a cursor that refers to the object
in the given element of the given list.
"""
super(OrderedListAsLinkedList.Cursor, self) \
.__init__(list)
self._element = element
def getDatum(self):
"""
(OrderedListAsLinkedList.Cursor) -> Object
Returns the object to which this cursor refers.
"""
return self._element.datum
#}>h
#{
def insertAfter(self, obj):
"""
(OrderedListAsLinkedList.Cursor, Object) -> None
Inserts the given object into the list
after the object to which this cursor refers.
"""
self._element.insertAfter(obj)
self._list._count += 1
#}>f
def insertBefore(self, obj):
"""
(OrderedListAsLinkedList.Cursor, Object) -> None
Inserts the given object into the list
before the object to which this cursor refers.
"""
self._element.insertBefore(obj)
self._list._count += 1
#{
def withdraw(self):
"""
(OrderedListAsLinkedList.Cursor) -> None
Withdraws from the list the object to which this cursor refers.
"""
self._list._linkedList.extract(self._element.datum)
self._list._count -= 1
#}>g
class Iterator(Iterator):
"""
Enumerates the items in an ordered list.
"""
def __init__(self, list):
"""
(OrderedListAsLinkedList.Iterator, OrderedListAsLinkedList) -> None
Constructs an iterator for the given list.
"""
super(OrderedListAsLinkedList.Iterator, self).__init__(list)
self._element = None
def next(self):
"""
(OrderedListAsLinkedList.Iterator) -> Object
Returns the next element.
"""
if self._element is None:
self._element = self._container._linkedList.head
else:
self._element = self._element.next
if self._element is None:
raise StopIteration
return self._element.datum
def __iter__(self):
"""
(OrderedListAsLinkedList) -> OrderedListAsLinkedList.Iterator
Returns an iterator for this ordered list.
"""
return self.Iterator(self)
def _compareTo(self, obj):
"""
(OrderedListAsLinkedList, OrderedListAsLinkedList) -> int
Compares this ordered list with the given ordered list.
"""
assert isinstance(self, obj.__class__)
raise NotImplementedError
@staticmethod
def main(*argv):
"OrderedListAsLinkedList test program."
print OrderedListAsLinkedList.main.__doc__
list = OrderedListAsLinkedList()
OrderedList.test(list)
return 0
class BinomialQueue(MergeablePriorityQueue):
"""
Mergeable priority queue implemented as a binomial queue.
"""
#}@head
#{
# ...
#}@tail
#{
def __init__(self, *args):
"""
(BinomialQueue, ...) -> None
Constructor.
"""
super(BinomialQueue, self).__init__()
self._treeList = LinkedList()
if len(args) == 0:
pass
elif len(args) == 1:
assert isinstance(args[0], self.BinomialTree)
self._treeList.append(args[0])
else:
raise ValueError
#}>a
#{
def addTree(self, tree):
"""
(BinomialQueue, BinomialQueue.BinomialTree) -> None
Adds the given binomial tree to this binomial queue.
"""
self._treeList.append(tree)
self._count += tree.count
def removeTree(self, tree):
"""
(BinomialQueue, BinomialQueue.BinomialTree) -> None
Removes the given binomial tree from this binomial queue.
"""
self._treeList.extract(tree)
self._count -= tree.count
#}>b
def purge(self):
"""
(BinomialQueue) -> None
Purges this binomial queue.
"""
self._treeList = LinkedList()
self._count = 0
def accept(self, visitor):
"""
(BinomialQueue, Visitor) -> None
Makes the given visitor visit the elements of this binomial queue.
"""
assert isinstance(visitor, Visitor)
ptr = self._treeList.head
while ptr is not None:
tree = ptr.datum
tree.depthFirstTraversal(PreOrder(visitor))
ptr = ptr.__next__
#{
def getMinTree(self):
"""
(BinomialQueue) -> BinomialQueue.BinomialTree
Returns the binomial tree in this binomial queue
with the smallest root.
"""
minTree = None
ptr = self._treeList.head
while ptr is not None:
tree = ptr.datum
if minTree is None or tree.key < minTree.key:
minTree = tree
ptr = ptr.__next__
return minTree
minTree = property(fget=lambda self: self.getMinTree())
def getMin(self):
"""
(BinomialQueue) -> Object
Returns the object in this binomial queue with the smallest value.
"""
if self._count == 0:
raise ContainerEmpty
return self.minTree.key
#}>c
#{
def merge(self, queue):
"""
(BinomialQueue, BinomialQueue) -> None
Merges the contents of the given binomial queue
with this binomial queue.
"""
oldList = self._treeList
self._treeList = LinkedList()
self._count = 0
p = oldList.head
q = queue._treeList.head
carry = None
i = 0
while p is not None or q is not None \
or carry is not None:
a = None
if p is not None:
tree = p.datum
if tree.degree == i:
a = tree
p = p.__next__
b = None
if q is not None:
tree = q.datum
if tree.degree == i:
b = tree
q = q.__next__
(sum, carry) = BinomialQueue.fullAdder(a, b, carry)
if sum is not None:
self.addTree(sum)
i += 1
queue.purge()
#}>d
#{
@staticmethod
def fullAdder(a, b, c):
"""
(BinomialTree, BinomialTree, BinomialTree) ->
(BinomialTree, BinomialTree)
Returns the (sum, carry) of the given binomial trees.
"""
if a is None:
if b is None:
if c is None:
return (None, None)
else:
return (c, None)
else:
if c is None:
return (b, None)
else:
return (None, b.add(c))
else:
if b is None:
if c is None:
return (a, None)
else:
return (None, a.add(c))
else:
if c is None:
return (None, a.add(b))
else:
return (c, a.add(b))
#}>e
#{
def enqueue(self, obj):
"""
(BinomialQueue, Object) -> None
Enqueues the given object in this binomial queue.
"""
self.merge(BinomialQueue(BinomialQueue.BinomialTree(obj)))
#}>f
#{
def dequeueMin(self):
"""
(BinomialQueue) -> Object
Dequeues and returns the object in this binomial queue
with the smallest value.
"""
if self._count == 0:
raise ContainerEmpty
minTree = self.minTree
self.removeTree(minTree)
queue = BinomialQueue()
while minTree.degree > 0:
child = minTree.getSubtree(0)
minTree.detachSubtree(child)
queue.addTree(child)
self.merge(queue)
return minTree.key
#}>g
def __str__(self):
"""
(BinomialQueue) -> str
Returns a string representation of this binomial queue.
"""
result = self.__class__.__name__ + " {\n"
ptr = self._treeList.head
while ptr is not None:
result = result + str(ptr.datum) + "\n"
ptr = ptr.__next__
result = result + "}"
return result
#{
class BinomialTree(GeneralTree):
"""
A binomial tree implemented as a general tree.
"""
#}@head
#{
# ...
#}@tail
#{
def __init__(self, key):
"""
(BinomialQueue.BinomialTree, Object) -> None
Constructor.
"""
super(BinomialQueue.BinomialTree, self).__init__(key)
#}>h
def getCount(self):
"""
(BinomialQueue.BinomialTree) -> int
Returns the number of objects in this binomial tree.
"""
return 1 << self._degree
def swapContentsWith(self, tree):
"""
(BinomialQueue.BinomialTree, BinomialQueue.BinomialTree) -> None
Swaps the contents of this binomial tree
with the given binomial tree.
"""
tmp = self._key
self._key = tree._key
tree._key = tmp
tmp = self._list
self._list = tree._list
tree._list = tmp
tmp = self._degree
self._degree = tree._degree
tree._degree = tmp
#{
def add(self, tree):
"""
(BinomialQueue.BinomialTree, BinomialQueue.BinomialTree) ->
BinomialQueue.BinomialTree
Adds this binomail tree and the given binomial tree.
"""
if self._degree != tree._degree:
raise ValueError
if self._key > tree._key:
self.swapContentsWith(tree)
self.attachSubtree(tree)
return self
#}>i
def _compareTo(self, obj):
"""
(BinomialQueue, BinomialQueue) -> int
Compares this binomial queue with the given binomial queue.
"""
assert isinstance(self, obj.__class__)
raise NotImplementedError
def __iter__(self):
"""
(BinomialQueue) -> iterator
Returns an iterator that enumerates the elements of this binomial queue.
"""
raise NotImplementedError
@staticmethod
def main(*argv):
"BinomialQueue test program."
print((BinomialQueue.main.__doc__))
pqueue = BinomialQueue()
PriorityQueue.test(pqueue)
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 QueueAsLinkedList(Queue):
"""
Queue implemented using a linked list.
"""
#}@head
#{
# ...
#}@tail
#{
def __init__(self):
"""
(QueueAsLinkedList) -> None
Constructs a queue.
"""
super(QueueAsLinkedList, self).__init__()
self._list = LinkedList()
def purge(self):
"""
(QueueAsLinkedList) -> None
Purges this queue.
"""
self._list.purge()
self._count = 0
#}>a
#{
def getHead(self):
"""
(QueueAsLinkedList) -> Object
Returns the object at the head of this queue.
"""
if self._count == 0:
raise ContainerEmpty
return self._list.first
def enqueue(self, obj):
"""
(QueueAsLinkedList, Object) -> None
Enqueues the given object to the tail of this queue.
"""
self._list.append(obj)
self._count += 1
def dequeue(self):
"""
(QueueAsLinkedList) -> Object
Dequeues the object at the head of this queue.
"""
if self._count == 0:
raise ContainerEmpty
result = self._list.first
self._list.extract(result)
self._count -= 1
return result
#}>b
def accept(self, visitor):
"""
(QueueAsLinkedList, Visitor) -> None
Makes the given visitor visit all the objects in this queue.
"""
assert isinstance(visitor, Visitor)
ptr = self._list.head
while ptr is not None:
visitor.visit(ptr.datum)
if visitor.isDone:
return
ptr = ptr.next
class Iterator(Iterator):
"""
Enumerates the elements of a QueueAsLinkedList.
"""
def __init__(self, queue):
"""
(QueueAsLinkedList.Iterator, QueueAsLinkedList) -> None
Constructs an iterator for the given queue.
"""
super(QueueAsLinkedList.Iterator).__init__(queue)
self._position = None
def next(self):
"""
(QueueAsLinkedList.Iterator) -> Object
Returns the next element.
"""
if self._position is None:
self._position = self._container._list.head
else:
self._position = self._position.next
if self._position is None:
raise StopIteration
return self._position.datum
def __iter__(self):
"""
(QueueAsLinkedList) -> QueueAsLinkedList.Iterator
Returns an iterator for this queue.
"""
return self.Iterator(self)
def _compareTo(self, obj):
"""
(QueueAsLinkedList, QueueAsLinkedList) -> int
Comparse this queue with the given queue.
"""
assert isinstance(self, obj.__class__)
raise NotImplementedError
@staticmethod
def main(*argv):
"QueueAsLinkedList test program."
print QueueAsLinkedList.main.__doc__
queue2 = QueueAsLinkedList()
Queue.test(queue2)
return 0
