class UnsortedPriorityQueue(PriorityQueueBase):
"""
A min-oriented priority queue implemented with an unsorted list.
"""
def __init__(self):
"""
Create an empty Priority Queue.
:return:
"""
self._data = PositionalList()
def _find_min(self):
"""
Return Position of item with minimum key.
:return:
"""
if self.is_empty():
raise Empty("Priority queue is empty.")
small = self._data.first()
walk = self._data.after(small)
while walk is not None:
if walk.element() < small.element():
small = walk
walk = self._data.after(walk)
return small
def min(self):
"""
Return but do not remove (k,v) tuple with minimum key.
:return:
"""
p = self._find_min()
item = p.element()
return (item._key, item._value)
def __len__(self):
"""
Return the number of items in the priority queue.
:return:
"""
return len(self._data)
def add(self, key, value):
"""
Add a key-value pair.
:param key:
:param value:
:return:
"""
self._data.add_last(self._Item(key, value))
def remove_min(self):
"""
Remove and return (k,v) tuple with minimum key.
:return:
"""
p = self._find_min()
item = self._data.delete(p)
return (item._key, item._value)
class UnsortedPriorityQueue(PriorityQueueBase):
def _recalculate_min(self):
if self.is_empty():
raise Empty("Priority queue is empty")
small = self._data.first()
walk = self._data.after(small)
while walk is not None:
if walk.element() < small.element():
small = walk
walk = self._data.after(walk)
self._min = small
def __init__(self):
self._data = PositionalList()
self._min = self._Item(float('inf'), None)
def __len__(self):
return len(self._data)
def add(self, key, value):
item = self._Item(key, value)
if key > self._min._key:
self._min = item
self._data.add_last(item)
def min(self):
item = self._min
return item._key, item._value
def remove_min(self):
p = self._min
item = self._data.delete(p)
self._recalculate_min()
return item._key, item._value
class UnsortedPriorityQueue(PriorityQueueBase):
def _find_min(self):
if self.is_empty():
raise Empty("Priority queue is empty")
small = self._data.first()
walk = self._data.after(small)
while walk is not None:
if walk.element() < small.element():
small = walk
walk = self._data.after(walk)
return small
def __init__(self):
self._data = PositionalList()
def __len__(self):
return len(self._data)
def add(self, key, value):
self._data.add_last(self._Item(key, value))
def min(self):
p = self._find_min()
item = p.element()
return item._key, item._value
def remove_min(self):
p = self._find_min()
item = self._data.delete(p)
return item._key, item._value
def top(self, k):
"""
Generate sequence of top k elements in terms of access count.
:param k:
:return:
"""
if not 1 <= k <= len(self):
raise ValueError("Illegal value for k.")
temp = PositionalList()
for item in self._data:
temp.add_last(item)
for j in range(k):
#find and report next highest form temp
## O(kn)
highPos = temp.first()
walk = temp.after(highPos)
while walk is not None:
if walk.element()._count > highPos.element()._count:
highPos = walk
walk = temp.after(walk)
yield highPos.element()._value
temp.delete(highPos)
def top(self, k):
"""
generate sequence of top k elements in terms of access count
:param k:
:return:
"""
if not 1 <= k <= len(self):
raise ValueError('illegal value for k')
# making a copy of the original list
temp = PositionalList()
for item in self._data: # positional lists support iteration
temp.add_last(item)
# repeatedly find, report and remove element with largest count
for j in range(k):
# find and report next highest from temp
highPos = temp.first()
walk = temp.after(highPos)
while walk is not None:
if walk.element()._count > highPos.element()._count:
highPos = walk
walk = temp.after(walk)
# found the element with highest count
yield highPos.element()._value # report element to user
temp.delete(highPos) # remove from temp list
def top(self, k):
"""
Generate sequence of top k elements in terms of access count.
:param k:
:return:
"""
if not 1 <= k <= len(self):
raise ValueError("Illegal value for k.")
temp = PositionalList()
for item in self._data:
temp.add_last(item)
for j in range(k):
#find and report next highest form temp
## O(kn)
highPos = temp.first()
walk = temp.after(highPos)
while walk is not None:
if walk.element()._count > highPos.element()._count:
highPos = walk
walk = temp.after(walk)
yield highPos.element()._value
temp.delete(highPos)
class UnsortedPriorityQueue(PriorityQueueBase):
""" A min-oriented priority queue implemented with an unsorted list
min() : O(n)
remove_min : O(n)
add() : O(1)
"""
def __init__(self):
self._data = PositionalList()
def __len__(self):
return len(self._data)
def add(self, key, value):
self._data.add_last(self._Item(key, value))
def min(self):
"""
:return: (k,v) tuple with minimum key (not remove)
"""
p = self._find_min()
item = p.element()
return (item._key, item._value)
def remove_min(self):
"""
:return: remove and return (k,v) with minimum key k
"""
p = self._find_min()
item = self._data.delete(p)
return (item._key, item._value)
def _find_min(self):
"""
:return: Position of item with minimum key
"""
if self.is_empty():
raise EmptyException('Priority Queue is empty')
small = self._data.first()
walk = self._data.after(small)
while walk is not None:
if walk.element() < small.element():
small = walk
walk = self._data.after(walk)
return small
def __str__(self):
res = []
walk = self._data.first()
while walk is not None:
item = walk.element()
res.append((item._key, item._value))
walk = self._data.after(walk)
return str(res)
def main():
global screen,SCREEN_WIDTH,SCREEN_SIZE,deltaX,deltaY
vertex=PositionalList()
running=True
done=False
clickTrue=False
getPrev=False
deltaX=0
deltaY=0
x=0
y=0
screen.fill((255,255,255))
while running:
for event in pygame.event.get():
if event.type==pygame.QUIT:
running=False
elif event.type==pygame.MOUSEBUTTONDOWN:
(posx,posy)=pygame.mouse.get_pos()
if done==False and len(vertex)>=0:
if (x-posx)**2+(y-posy)**2<=25:
vertex.add_last(vertex.first().element())
else:
vertex.add_last((posx,posy))
if len(vertex)>1:
(x,y)=vertex.first().element()
if (x-posx)**2+(y-posy)**2<=25:
done=True
(posx,posy)=vertex.first().element()
p=vertex.before(vertex.last())
pygame.draw.line(screen,(0,0,0),p.element(),(posx,posy))
pygame.draw.circle(screen,(0,0,0),(posx,posy),5)
else:
if click(vertex,(posx,posy)):
clickTrue=not clickTrue
getPrev=False
elif event.type==pygame.MOUSEMOTION and clickTrue:
if done==True:
(posx,posy)=pygame.mouse.get_pos()
screen.fill((255,255,255))
if getPrev:
deltaX=(posx-pPosx)
deltaY=(posy-pPosy)
updateVertex(vertex,deltaX,deltaY)
drawPolygon(vertex)
getPrev=True
(pPosx, pPosy) = (posx,posy)
elif event.type==pygame.MOUSEBUTTONUP:
clickTrue=False
pygame.display.flip()
class FavoritesList:
""" List of elements from most accessed to list """
class _Item:
__slots__ = '_value', '_count'
def __init__(self, e):
self._value = e
self._count = 0
def __init__(self):
self._data = PositionalList()
def __len__(self):
return len(self._data)
def is_empty(self):
return len(self._data) == 0
def _find_position(self, e):
walk = self._data.first()
while walk is not None and walk.element()._value != e:
walk = self._data.after(walk)
return walk
def _move_up(self, p):
""" Based on access count
"""
if p != self._data.first():
cnt = p.element()._count
walk = self._data.before(p)
if cnt > walk.element()._count:
while (walk != self._data.first()
and cnt > self._data.before(walk).element()._count):
walk = self._data.before(walk)
self._data.add_before(walk, self._data.delete(p))
def access(self, e):
p = self._find_position(e)
if p is None:
p = self._data.add_last(self._Item(e))
p.element()._count += 1
self._move_up(p)
def remove(self, e):
p = self._find_position(e)
if p is not None:
self._data.delete(p)
def top(self, k):
"""
:return: sequence of top k elements
"""
if not 1 <= k <= len(self):
raise ValueError('Illegal value for k')
walk = self._data.first()
for j in range(k):
item = walk.element()
yield item._value
walk = self._data.after(walk)
class FavoritesList:
class _Item:
__slots__ = '_value', '_count'
def __init__(self, v):
self._value = v
self._count = 0
def _find_position(self, e):
""" Search for element e and return its Position """
walk = self._data.first()
while walk is not None and walk.element()._value != e:
walk = self._data.after(walk)
return walk
def _move_up(self, p):
""" Move item at Position p earlier in the list based on access count """
if p != self._data.first():
walk = self._data.before(p)
cnt = p.element()._count
if cnt > walk.element()._count:
while walk != self._data.first() and cnt > self._data.before(
walk).element()._count:
walk = self._data.before(walk)
self._data.add_before(walk, self._data.delete(p))
""" ==================================Public Methods==================================== """
def __init__(self):
self._data = PositionalList()
def __len__(self):
return len(self._data)
def is_empty(self):
return self._data.is_empty()
def access(self, e):
""" Access element e, thereby increasing its access count """
p = self._find_position(e)
if p is None:
p = self._data.add_last(self._Item(e))
p.element()._count += 1
self._move_up(p)
def remove(self, e):
p = self._find_position(e)
if p is not None:
self._data.delete(p)
def top(self, k):
if not 1 <= k <= len(self):
raise ValueError("Illegal value for k")
walk = self._data.first()
for _ in range(k):
item = walk.element()._value
yield item
walk = self._data.after(walk)
def top(self, k):
if not 1 <= k <= len(self):
raise ValueError("Ilegal value for k")
temp = PositionalList()
for item in self._data:
temp.add_last(item)
for j in range(k):
highPos = temp.fist()
walk = temp.after(highPos)
while walk is not None:
if walk.element()._count > highPos.element()._count:
highPos = walk
walk = temp.after(walk)
yield highPos.element()._value
temp.delete(highPos)
def top(self, k):
if not 1 <= k <= len(self):
raise ValueError('Bad k')
temp = PositionalList()
for item in self._data:
temp.add_last(item)
# we repeatedly find, report, and remove element with largest count
for j in range(k):
highPos = temp.first()
walk = temp.after(highPos)
while walk is not None:
if walk.element()._count > highPos.element()._count:
highPos = walk
walk = temp.after(walk)
yield highPos.element()._value
temp.delete(highPos)
def top(self, k):
"""Generate sequnce of top k elements in terms of access count"""
if not 1 <= k <= len(self):
raise ValueError("Illegal value for k")
# we begin by making a copy of the original list
temp = PositionalList()
for item in self._data:
temp.add_last(item)
# we repeatedly find, report, and remove element with largest count
for j in range(k):
# find and report next highest from temp
highPos = temp.first()
walk = temp.after(highPos)
while walk is not None:
if walk.element()._count > highPos.element()._count:
highPos = walk
walk = temp.after(walk)
# we have found the element with highest count
yield highPos.element()._value
temp.delete(highPos)
def top(self, k):
"""Generate sequence of top k elements in terms of access count."""
if not 1 <= k <= len(self):
raise ValueError('Illegal value for k')
# we begin by making a copy of the original list
temp = PositionalList()
for item in self._data: # positional lists support iteration
temp.add_last(item)
# we repeatedly find, report, and remove element with largest count
for j in range(k):
# find and report next highest from temp
highPos = temp.first()
walk = temp.after(highPos)
while walk is not None:
if walk.element()._count > highPos.element()._count:
highPos = walk
walk = temp.after(walk)
# we have found the element with highest count
yield highPos.element()._value # report element to user
temp.delete(highPos) # remove from temp list
class UnsortedPriorityQueue(PriorityQueueBase):
"""A min-oriented priority queue implemented with an unsorted list"""
def __init__(self):
self._data = PositionalList()
def _find_min(self):
"""Return Position of item with minimum key"""
if self._data.is_empty(): # empty queue
raise ValueError("Empty Priority Queue")
small = self._data.first()
walk = self._data.after(small)
while walk != None:
# find a item with smaller key or higher priority
if small.element() > walk.element():
small = walk
walk = self._data.after(walk)
return small
def __len__(self):
return len(self._data)
def add(self, key, value):
"""Add a key-value pair"""
self._data.add_last(self._Item(key, value))
def min(self):
"""Return but do not remove (k,v) tuple with minimum key"""
item = self._find_min().element()
return item._key, item._value
def remove_min(self):
"""Remove and return (k,v) tuple with minimum key"""
p = self._find_min() # find the position
item = self._data.delete(
p) # delete the position and return the element
return item._key, item._value
class UnsortedPQ(PriorityQueueBase):
""" Unsorted priority queue """
def __init__(self):
self._data = PositionalList()
def __len__(self):
return len(self._data)
def _find_min(self):
if self.is_empty():
raise Empty("Queue is empty!")
min = self._data.first()
walker = self._data.after(min)
while walker is not None:
if min.item() > walker.item():
min = walker
walker = self._data.after(walker)
return min
def min(self):
p = self._find_min()
return p.item()._key, p.item()._val
def remove_min(self):
p = self._find_min()
item = p.item()
self._data.delete(p)
return item._key, item._val
def add(self, k, v):
self._data.add_last(self._Item(k, v))
def __iter__(self):
for item in self._data:
yield item
class AdaptableUnsortedPriorityQueue(PriorityQueueBase):
class Locator(PriorityQueueBase._Item):
__slots__ = '_index'
def __init__(self, k, v, j):
super().__init__(k, v)
self._index = j
def update(self, loc, newkey, newval):
item = loc.element()
item._value = newval
item._key = newkey
def remove(self, loc):
item = self._data.remove(loc)
return item._key, item._value
def _find_min(self):
if self.is_empty():
raise Empty("Priority queue is empty")
small = self._data.first()
walk = self._data.after(small)
while walk is not None:
if walk.element() < small.element():
small = walk
walk = self._data.after(walk)
return small
def __init__(self):
self._data = PositionalList()
def __len__(self):
return len(self._data)
def add(self, key, value):
return self._data.add_last(self._Item(key, value))
def min(self):
p = self._find_min()
item = p.element()
return item._key, item._value
def remove_min(self):
p = self._find_min()
item = self._data.delete(p)
return item._key, item._value
class FavorateListMTFAd(FavoritesListMTF):
"""Subclass of FavoritesListMTF,but the elements that have not been
accessed in the most resent n accesses are automatically purged
from the list.
"""
#------------------------------ nested Item class ------------------------------
class _Item:
__slots__ ='_value','_count'# streamline memory usage
def __init__ (self, e):
self._value = e # the user s element
self._count = 0 # access count initially zero
self._accessnum = 0
def __init__ (self,maxnum):
"""Create an empty list of favorites."""
self._data = PositionalList() # will be list of Item instances
self._accessnum = 0
self._max = maxnum
def access(self, e):
"""Access element e, thereby increasing its access count."""
self._accessnum += 1
p = self._find_position(e) # try to locate existing element
if p is None:
p = self._data.add_last(self._Item(e)) # if new, place at end
p.element()._count += 1 # always increment count
p.element()._accessnum = self._accessnum
self._move_up(p) # consider moving forward
if self._data.last().element()._accessnum == (self._accessnum - self._max) :
self._data.delete(self._data.last())
def showinfo(self):
"""Show the infomation of the current list"""
print 'Favoriteslist info:[',
for i in self:
print '(',i._value,',',i._count,',',i._accessnum,')',
print ']'
class FavoritesList:
"""
list of elements ordered from most frequently accessed to lest
"""
# ------------ nested _Item class ---------------------------
class _Item:
__slots__ = '_value', '_count' # streamline memory usage
def __init__(self, element):
self._value = element # the user's element
self._count = 0 # access count initially zero
# ------------ non-public utilities --------------------------
def _find_position(self, element):
"""
search for element and return its Position (or None if not found)
:param element:
:return:
"""
walk = self._data.first()
while walk is not None and walk.element()._value != element:
walk = self._data.after(walk)
return walk
def _move_up(self, position):
"""
move item at position earlier in the list based on access count
:param position:
:return:
"""
if position != self._data.first(): # consider moving
cnt = position.element()._count
walk = self._data.before(position)
if cnt > walk.element()._count: # must shift forward
while (walk != self._data.first() and cnt > self._data.before(walk).element()._count):
walk = self._data.before(walk)
self._data.add_before(walk, self._data.delete(position)) # delete / reinsert
# ------------ public methods ---------------------------------
def __init__(self):
"""
create an empty list of favorites
"""
self._data = PositionalList() # list of _Item instances
def __len__(self):
"""
return number of entries on favorites list
:return:
"""
return len(self._data)
def is_empty(self):
"""
return True if list is empty
:return:
"""
return len(self._data) == 0
def access(self, element):
"""
access element, thereby increasing its access count
:param element:
:return:
"""
position = self._find_position(element) # try to locate existing element
if position is None:
position = self._data.add_last(self._Item(element)) # if new, place at end
position.element()._count += 1 # always increment count
self._move_up(position) # consider moving forward
def remove(self, element):
"""
remove element from the list of favorites
:param element:
:return:
"""
position = self._find_position(element) # try to locate existing element
if position is not None: # delete if found
self._data.delete(position)
def top(self, k):
"""
generate sequence of top k elements in terms of access count
:param k:
:return:
"""
if not 1 <= k <= len(self):
raise ValueError('Illegal value for k')
walk = self._data.first()
for j in range(k):
item = walk.element() # element of list is _Item
yield item._value
walk = self._data.after(walk)
def clear(self):
"""
returns the list to empty.
:return:
"""
self._data = PositionalList()
def reset_counts(self):
"""
resets all elements’ access counts to zero (while leaving the order of
he list unchanged).
:return:
"""
cursor = self._data.first()
while cursor is not None:
cursor.element()._count = 0
cursor = self._data.after(cursor)
print(i, L)
# P 407
def pq_sort(C):
"""
sort a collection of elements stored in a positional list
:param C:
:return:
"""
assert isinstance(C, PositionalList)
n = len(C)
P = HeapPriorityQueue() # could be any PriorityQueue
# HeapPriorityQueue: O(nlogn) or O(n)[bottom-up heap construction]
# UnsortedPriorityQueue: O(n^2) selection-sort
# sortedPriorityQueue: O(n^2) insertion-sort
for j in range(n):
element = C.delete(C.first())
P.add(element, element) # use element as key and value
for j in range(n):
(k, v) = P.remove_min()
C.add_last(v) # store smallest remaining element in C
p = PositionalList()
for i in range(10):
p.add_last(randint(1, 100))
print(p)
pq_sort(p)
print(p)
pivot = L.after(marker) # next item to place
value = pivot.element()
if value > marker.element(): # pivot is already sorted
marker = pivot
else: # must relocate pivot
walk = marker # find leftmost item greater than value
while walk != L.first() and L.before(walk).element() > value:
walk = L.before(walk)
L.delete(pivot)
L.add_before(walk, value) # reinsert value before walk
pl = PositionalList()
num = [15,22,25,29,36,23,53,11,42]
for n in num:
pl.add_last(n)
print('PositionalList before sorting: ', pl)
insertion_sort(pl)
print('PositionalList after sorting: ', pl)
# P 309
class FavoritesList:
"""
list of elements ordered from most frequently accessed to lest
"""
# ------------ nested _Item class ---------------------------
class _Item:
__slots__ = '_value', '_count' # streamline memory usage
class FavoritesList:
"""
List of elements ordered from most frequently accessed to least.
"""
#------------------------------ nested Item class ------------------------------
class _Item:
__slots__ = '_value', '_count'
def __init__(self, e):
self._value = e
self._count = 0
#------------------------------- nonpublic utilities -------------------------------
def _find_position(self, e):
"""
Search for element e and return its Position (or None if not found).
:param e:
:return:
"""
walk = self._data.first()
while walk is not None and walk.element()._value != e:
walk = self._data.after(walk)
return walk
def _move_up(self, p):
"""
Move item at Position p earlier in the list based on access count.
:param p:
:return:
"""
if p != self._data.first():
cnt = p.element()._count
walk = self._data.before(p)
if cnt > walk.element()._count:
while (walk != self._data.first() and cnt > self._data.before(walk)._count):
walk = self._data.before(walk)
self._data.add_before(walk, self._data.delete(p))
#------------------------------- public methods -------------------------------
def __init__(self):
"""
Create an empty list of favorites.
:return:
"""
self._data = PositionalList()
def __len__(self):
"""
Return number of entries on favorites list.
:return:
"""
return len(self._data)
def is_empty(self):
"""
Return True is list is empty.
:return:
"""
return len(self._data) == 0
def access(self, e):
"""
Access element e,thereby increasing its access count.
:param e:
:return:
"""
p = self._find_position(e)
if p is None:
p = self._data.add_last(self._Item(e))
p.element()._count += 1
self._move_up(p)
def remove(self, e):
"""
Remove element e from the list of favorites
:param e:
:return:
"""
p = self._find_position(e)
if p is not None:
self._data.delete(p)
def top(self, k):
"""
Generate sequence of top k elements in terms of access count.
:param e:
:return:
"""
if not 1 <= len(self):
raise ValueError('Illegal value for k')
walk = self._data.first()
for j in range(k):
item = walk.element()
yield item._value
walk = self._data.after(walk)
Its O(N)
"""
from PositionalList import PositionalList
def bubble_sort(l):
for _ in range(len(l)):
cur = l.first()
x = 1
while len(l) > x:
next = l.after(cur)
if cur.element() > next.element():
l.swap_position(cur, next)
x += 1
x += 1
cur = l.after(cur)
a = PositionalList()
a.add_last(1)
a.add_last(5)
a.add_last(3)
a.add_last(2)
bubble_sort(a)
# a.swap_position(a.first(),a.last())
# print(len(a))
for x in a:
print(x)
# [print(x) for x in a]
"""
if len(pl) <= 1:
return
if not isinstance(pl, PositionalList):
return
marker = pl.first()
while marker != pl.last():
pivot = pl.after(marker)
value = pivot.element()
if value > marker.element():
marker = pivot
else:
walk = marker
while walk != pl.first() and pl.before(walk).element() > value:
walk = pl.before(walk)
pl.delete(pivot)
pl.add_before(walk, value)
if __name__ == '__main__':
pl = PositionalList()
for k in range(10, 0, -2):
pl.add_last(k)
print(pl)
sorter = InsertionSort()
sorter.insertion_sort(pl)
print(pl)
from PositionalList import PositionalList
def printlist(L,s):
print(s,end=": ")
for i in L:
print(i,end=' ')
print()
L1 = PositionalList()
L2 = PositionalList()
for i in range(5):
L1.add_last(i)
L2.add_last(i + 5)
if True: #Once again, turn these on as you advance through this assignment.
#Leave them all on when you hand in.
#Task 1: Append the elements of a given list the end of a list.
#The given list is basically destroyed.
#¡Do this in constant time!
L1.append(L2)
printlist(L1, 'L1 after appending L2')
printlist(L2, 'L2 after being appended L1')
L2.add_last('seventeen')
printlist(L1, 'L1 after adding \'seventeen\' to L2')
printlist(L2, 'L2 after adding \'seventeen\' to it')
# Output
# L1 after appending L2: 0 1 2 3 4 5 6 7 8 9
# L2 after being appended L1:
#
# (so L2 is empty)
# L1 after adding 'seventeen' to L2: 0 1 2 3 4 5 6 7 8 9
# L2 after adding 'seventeen' to it: seventeen
class FavoritesList:
class _Item:
def __init__(self, val):
self._value = val
self._count = 0
def __init__(self):
self._data = PositionalList()
""" nonpublic utilities """
def _find_position(self, val):
walker = self._data.first()
while walker is not None and walker.item()._value != val:
walker = self._data.after(walker)
return walker
def _move_up(self, p):
if p != self._data.first():
walker = self._data.before(p)
cnt = p.item()._count
if cnt > walker.item()._count:
while walker != self._data.first() and cnt > self._data.before(walker).item()._count:
walker = self._data.before(walker)
self._data.add_before(self._data.delete(p), walker)
""" public methods"""
def __len__(self):
return len(self._data)
def is_empty(self):
return len(self._data) == 0
def access(self, val):
p = self._find_position(val)
if p is None:
p = self._data.add_last(self._Item(val))
p.item()._count += 1
self._move_up(p)
def access_item(self, item):
val = item._value
p = self._find_position(val)
if p is None:
p = self._data.add_last(item)
self._move_up(p)
def remove(self, val):
p = self._find_position(val)
if p is not None:
self._data.delete(p)
def top(self, k):
if not 1 <= k <= len(self):
raise ValueError('Illegal value for k')
walker = self._data.first()
for i in range(k):
yield walker.item()._value
walker = self._data.after(walker)
class FavoritesList:
"""
List of elements ordered from most frequently accessed to least.
"""
#------------------------------ nested Item class ------------------------------
class _Item:
__slots__ = '_value', '_count'
def __init__(self, e):
self._value = e
self._count = 0
#------------------------------- nonpublic utilities -------------------------------
def _find_position(self, e):
"""
Search for element e and return its Position (or None if not found).
:param e:
:return:
"""
walk = self._data.first()
while walk is not None and walk.element()._value != e:
walk = self._data.after(walk)
return walk
def _move_up(self, p):
"""
Move item at Position p earlier in the list based on access count.
:param p:
:return:
"""
if p != self._data.first():
cnt = p.element()._count
walk = self._data.before(p)
if cnt > walk.element()._count:
while (walk != self._data.first()
and cnt > self._data.before(walk)._count):
walk = self._data.before(walk)
self._data.add_before(walk, self._data.delete(p))
#------------------------------- public methods -------------------------------
def __init__(self):
"""
Create an empty list of favorites.
:return:
"""
self._data = PositionalList()
def __len__(self):
"""
Return number of entries on favorites list.
:return:
"""
return len(self._data)
def is_empty(self):
"""
Return True is list is empty.
:return:
"""
return len(self._data) == 0
def access(self, e):
"""
Access element e,thereby increasing its access count.
:param e:
:return:
"""
p = self._find_position(e)
if p is None:
p = self._data.add_last(self._Item(e))
p.element()._count += 1
self._move_up(p)
def remove(self, e):
"""
Remove element e from the list of favorites
:param e:
:return:
"""
p = self._find_position(e)
if p is not None:
self._data.delete(p)
def top(self, k):
"""
Generate sequence of top k elements in terms of access count.
:param e:
:return:
"""
if not 1 <= len(self):
raise ValueError('Illegal value for k')
walk = self._data.first()
for j in range(k):
item = walk.element()
yield item._value
walk = self._data.after(walk)
class UnsortedPriorityQueue(PriorityQueueBase):
"""
a min-oriented priority queue implemented with an unsorted list
"""
# base class defines _Item
def _find_min(self): # nonpublic utility
"""
return Position of item with minimum key
:return:
"""
if self.is_empty():
raise Empty('priority queue is empty')
small = self._data.first()
walk = self._data.after(small)
while walk is not None:
if walk.element() < small.element():
small = walk
walk = self._data.after(walk)
return small
def __init__(self):
"""
create a new empty Priority Queue
"""
self._data = PositionalList()
def __len__(self):
"""
return the number of items in the priority queue
:return:
"""
return len(self._data)
def add(self, key, value):
"""
add a key-value pair
:param key:
:param value:
:return:
"""
self._data.add_last(self._Item(key, value))
def min(self):
"""
return but do not remove (k,v) pair with minimum key
:return:
"""
p = self._find_min() # return the position
item = p.element()
return (item._key, item._value)
def remove_min(self):
"""
remove and return (k,v) pair with minimum key
:return:
"""
p = self._find_min() # return the position
item = self._data.delete(p)
return (item._key, item._value)
in nondecreasing order, and another value V, and determines in O(n) time
if there are two elements of L that sum precisely toV. The function should
return a pair of positions of such elements, if found, or None otherwise
"""
from PositionalList import PositionalList
def find_pair(l, v):
start, end = l.first(), l.last()
while 1:
start_val, end_val = start.element(), end.element()
if end_val > v:
end = l.before(end)
elif end_val + start_val < v:
start = l.after(start)
if start is None:
return None
elif end_val + start_val > v:
return None
else:
print('its a match', end_val, start_val)
return end_val, start_val
a = PositionalList()
for b in range(0,100,3):
a.add_last(b)
find_pair(a, 33)
pp.add_first(random.randint(0, 100))
print(pp)
rp = reversed(pp)
for i in rp: print(i, end=" ")
print()
# R-7.16
# Describe an implementation of the PositionalList methods add last and
# add before realized by using only methods in the set {is empty, first, last,
# prev, next, add after, and add first} .
pp = PositionalList()
pp.add_last2(500)
for _ in range(5):
pp.add_first(random.randint(0, 3))
pp.add_last(1000); print(pp)
pp.add_last2(2000); print(pp)
pp.add_before(pp.first(), 3000); print(pp)
pp.add_before2(pp.first(), 4000); print(pp)
pp.add_before2(pp.last(), 5000); print(pp)
# R-7.17
# move an element of a list at position p to become the first
# element of the list, while keeping the relative order of the remaining elements
# unchanged.
# Augment the PositionalList
# class to support a new method, move to front(p), that accomplishes this
# goal more directly, by relinking the existing node.
pp = PositionalList()
for i in range(5):
add() takes O(nlogn)
remove_min() takes O(nlogn)
Total Running Time = O(nlogn)
Improvements : use Bottom-up heap construction to reduce
phase 1 running time to O(n)
"""
if not isinstance(c, PositionalList):
raise TypeError('Must pass positional list')
n = len(c)
P = HeapPriorityQueue()
for j in range(n):
element = c.delete(c.first())
P.add(element, element)
for j in range(n):
(k, v) = P.remove_min()
c.add_last(v)
if __name__ == '__main__':
sorter = PriorityQueueSort()
l = PositionalList()
l.add_last(4)
l.add_last(3)
l.add_last(5)
l.add_last(1)
l.add_last(2)
print('Unsorted list is ', l)
sorter.pq_selection_sort(l)
print('Sorted list is ', l)
class FavoritesList:
"""List of elements ordered from most frequently accessed to least."""
# ------------------------------ nested _Item class ------------------------------
class _Item:
__slots__ = '_value', '_count' # streamline memory usage
def __init__(self, e):
self._value = e # the user's element
self._count = 0 # access count initially zero
# ------------------------------- nonpublic utilities -------------------------------
def _find_position(self, e):
"""Search for element e and return its Position (or None if not found)."""
walk = self._data.first()
while walk is not None and walk.element()._value != e:
walk = self._data.after(walk)
return walk
def _move_up(self, p):
"""Move item at Position p earlier in the list based on access count."""
if p != self._data.first(): # consider moving...
cnt = p.element()._count
walk = self._data.before(p)
if cnt > walk.element()._count: # must shift forward
while (walk != self._data.first()
and cnt > self._data.before(walk).element()._count):
walk = self._data.before(walk)
self._data.add_before(walk,
self._data.delete(p)) # delete/reinsert
# ------------------------------- public methods -------------------------------
def __init__(self):
"""Create an empty list of favorites."""
self._data = PositionalList() # will be list of _Item instances
def __len__(self):
"""Return number of entries on favorites list."""
return len(self._data)
def is_empty(self):
"""Return True if list is empty."""
return len(self._data) == 0
def access(self, e):
"""Access element e, thereby increasing its access count."""
p = self._find_position(e) # try to locate existing element
if p is None:
p = self._data.add_last(self._Item(e)) # if new, place at end
p.element()._count += 1 # always increment count
self._move_up(p) # consider moving forward
def remove(self, e):
"""Remove element e from the list of favorites."""
p = self._find_position(e) # try to locate existing element
if p is not None:
self._data.delete(p) # delete, if found
def top(self, k):
"""Generate sequence of top k elements in terms of access count."""
if not 1 <= k <= len(self):
raise ValueError('Illegal value for k')
walk = self._data.first()
for j in range(k):
item = walk.element() # element of list is _Item
yield item._value # report user's element
walk = self._data.after(walk)
def __repr__(self):
"""Create string representation of the favorites list."""
return ', '.join('({0}:{1})'.format(i._value, i._count)
for i in self._data)
class FavoritesList:
"""List of elements ordered from most frequently accessed to least."""
#------------------------------ nested Item class ------------------------------
class _Item:
__slots__ ='_value','_count'# streamline memory usage
def __init__ (self, e):
self._value = e # the user s element
self._count = 0 # access count initially zero
#------------------------------- nonpublic utilities -------------------------------
def _find_position(self, e):
"""Search for element e and return its Position (or None if not found)."""
walk = self._data.first()
while walk is not None and walk.element()._value != e:
walk = self._data.after(walk)
return walk
def _move_up(self, p):
"""Move item at Position p earlier in the list based on access count."""
if p != self._data.first(): # consider moving...
cnt = p.element()._count
walk = self._data.before(p)
if cnt > walk.element()._count: # must shift forward
while (walk != self._data.first() and
cnt > self._data.before(walk).element()._count):
walk = self._data.before(walk)
self._data.add_before(walk, self._data.delete(p)) # delete/reinsert
#------------------------------- public methods -------------------------------
def __init__ (self):
"""Create an empty list of favorites."""
self._data = PositionalList() # will be list of Item instances
def __iter__(self):
"""Generate a forward iteration of the elements of the list."""
for i in self._data:
yield i
def __reversed__(self):
"""Generate a backward iteration of the elements of the list."""
for i in reversed(self._data):
yield i
def __len__(self):
"""Return number of entries on favorites list."""
return len(self._data)
def is_empty(self):
"""Return True if list is empty."""
return len(self._data) == 0
def access(self, e):
"""Access element e, thereby increasing its access count."""
p = self._find_position(e) # try to locate existing element
if p is None:
p = self._data.add_last(self._Item(e)) # if new, place at end
p.element()._count += 1 # always increment count
self._move_up(p) # consider moving forward
def remove(self, e):
"""Remove element e from the list of favorites."""
p = self._find_position(e) # try to locate existing element
if p is not None:
self._data.delete(p) # delete, if found
def top(self, k):
"""Generate sequence of top k elements in terms of access count."""
if not 1 <= k <= len(self):
raise ValueError('Illegal value for k')
walk = self._data.first()
for j in range(k):
item = walk.element() # element of list is Item
yield item._value # report user’s element
walk = self._data.after(walk)
def clear(self):
"""Clean the list into empty"""
self._data = PositionalList() # will be list of Item instances
def reset_count(self):
"""Reset the count of element in list leaving the order unchanged"""
for i in self:
i._count = 0
def showinfo(self):
"""Show the infomation of the current list"""
print 'Favoriteslist info:[',
for i in self:
print '(',i._value,',',i._count,')',
print ']'
def showelement(self):
"""Show the element of the current list"""
print 'Favoriteslist elements:[',
for i in self:
print i._value,
print ']'
