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
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 SortedPQ(PriorityQueueBase): """ Sorted priority queue""" def __init__(self): self._data = PositionalList() def __len__(self): return len(self._data) def add(self, k, v): newest = self._Item(k, v) walk = self._data.last() while walk is not None and newest < walk.item(): walk = self._data.before(walk) if walk is None: self._data.add_first(newest) else: self._data.add_after(newest, walk) def min(self): item = self._data.first().item() return item._key, item._val def remove_min(self): p = self._data.first() item = p.item() self._data.delete(p) return item._key, item._val def __iter__(self): for item in self._data: yield item
class SortedPriorityQueue(PriorityQueueBase): def __init__(self) -> None: self._data = PositionalList() def __len__(self): return len(self._data) def __iter__(self): return iter(self._data) def add(self, key, value): newest: self._Item = self._Item(key, value) walk = self._data.last() while walk is not None and newest < walk.element(): walk = self._data.before(walk) if walk is None: self._data.add_first(newest) else: self._data.add_after(walk, newest) def min(self): if self.is_empty(): raise Exception("Priority queue is empty") p = self._data.first() item = p.element() return (item._key, item._value) def remove_min(self): if self.is_empty(): raise Exception('Priority queue is empty.') item = self._data.delete(self._data.first()) return (item._key, item._value)
class SortedPriorityQueue(PriorityQueueBase): """A min-oriented priority queue implemented with a sorted list""" def __init__(self): self._data = PositionalList() def __len__(self): return len(self._data) def min(self): if self.is_empty(): raise ValueError("Empty Priority Queue") item = self._data.first().element() return item._key, item._value def remove_min(self): if self.is_empty(): raise ValueError("Empty Priority Queue") item = self._data.delete(self._data.first()) return item._key, item._value def add(self, key, value): new_item = self._Item(key, value) walk = self._data.last() # walk backwards for smaller key while walk != None and new_item < walk.element(): walk = self._data.before(walk) if walk: self._data.add_after(new_item, walk) else: # walk is the header self._data.add_first(new_item)
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
class SparseArray: def __init__(self): self._data = PositionalList() def __getitem__(self, item): for i, e in self._data: if i == item: return e def __setitem__(self, key, value): self._data.add_first((key, value))
class SortedPriorityQueue(PriorityQueueBase): """ a min-oriented priority queue implemented with a sorted list """ # base class defines _Item 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: """ newest = self._Item(key, value) # make new item instance walk = self._data.last( ) # walk backward looking for smaller key, [last() return a position] while walk is not None and newest < walk.element(): walk = self._data.before(walk) if walk is None: self._data.add_first(newest) # new key is smallest else: self._data.add_after(walk, newest) # newest goes after walk def min(self): """ return but do not remove (k,v) tuple with minimum key :return: """ if self.is_empty(): raise Empty('priority queue is empty') p = self._data.first() # return a position item = p.element() return (item._key, item._value) def remove_min(self): """ remove and return (k,v) tuple with minimum key :return: """ if self.is_empty(): raise Empty('priority queue is empty') item = self._data.delete( self._data.first()) # delete() return the element return (item._key, item._value)
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 SortedPriorityQueue(PriorityQueueBase): """ A min-oriented priority queue implemented with an sorted list. """ def __init__(self): """ Create a new empty Priority Queue. :return: """ 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: """ newest = self._Item(key, value) walk = self._data.last() while walk is not None and newest < walk.element(): walk = self._data.before(walk) if walk is None: self._data._add_first(newest) else: self._data.add_before(walk, newest) def min(self): """ Return but do not remove(k,v) tuple with minimum key. :return: """ if self.is_empty(): raise Empty("Priority queue is empty.") p = self._data.first() item = p.element() return (item._key, item._value) def remove_min(self): """ Remove and return (k,v) tuple with minimun key. :return: """ if self.is_empty(): raise Empty("Priority queue is empty.") item = self._data.delete(self._data.first()) return (item._key, item._value)
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 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 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)
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 UnsortedTableMap(MapBase): def __init__(self): self._data = PositionalList() def __getitem__(self, k): for item in self._data: if k == item.element()._key: return item.element()._value raise KeyError('Key Error: ' + repr(k)) def __setitem__(self, key, value): for item in self._data: if key == item.element()._key: self._data.replace(item, self._Item(key, value)) return self._data.add_first(self._Item(key, value)) def __delitem__(self, key): for item in self._data: if key == item.element()._key: self._data.delete(item) return raise KeyError("Key Error: " + repr(key)) def __len__(self): return len(self._data) def __iter__(self): for item in self._data: yield item.element()._key
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)
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 ']'
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 PositionalQueue: def __init__(self): self._data = PositionalList() def __len__(self): return len(self._data) def enqueue(self, el): return self._data.add_first(el) def dequeue(self): return self._data.delete(self._data.last()) def delete(self, pos): return self._data.delete(pos) def before(self, p): return self._data.before(p) def after(self, p): return self._data.after(p)
""" 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)
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]
def __init__(self): """ Create an empty Priority Queue. :return: """ self._data = PositionalList()
def __init__(self): """ Create an empty list of favorites. :return: """ self._data = PositionalList()
def __init__(self): """ create an empty list of favorites """ self._data = PositionalList() # list of _Item instances
class SortedPriorityQueue(PriorityQueueBase): """ A min-oriented priority queue implementation with sorted list min() : O(1) remove_min : O(1) add() : O(n) """ def __init__(self): self._data = PositionalList() def __len__(self): return len(self._data) def add(self, key, value): """ Add a key-value pair at a correct position """ newest = self._Item(key, value) # walk backward walk = self._data.last() while walk is not None and newest < walk.element(): walk = self._data.before(walk) if walk is None: # new key is smallest self._data.add_first(newest) else: self._data.add_after(walk, newest) def min(self): """ :return: tuple (key, value) with minimum key """ if self.is_empty(): raise EmptyException('Priority Queue is empty') p = self._data.first() item = p.element() return (item._key, item._value) def remove_min(self): if self.is_empty(): raise EmptyException('Priority Queue is Empty') item = self._data.delete(self._data.first()) return (item._key, item._value) 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 __init__ (self): """Create an empty list of favorites.""" self._data = PositionalList() # will be list of Item instances
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: """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)
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 __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 ']'
def __init__(self): self._data = PositionalList()
""" 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) if __name__ == "__main__": pl = PositionalList() pl.add_first(1) pl.add_first(34) p25 = pl.add_first(25) pl.add_first(35) pl.add_first(40) print([el for el in iter(pl)]) print "the last element in list is %s" % pl.last().element() print "the first element in list is %s" % pl.first().element() print "the element before " print ("the element before 25 is %s") % pl.before(p25).element() print ("the element after 25 is %s") % pl.after(p25).element() print ("Delete the element %s " % pl.delete(p25)) print([el for el in iter(pl)]) print("now Sort the list ..")
if len(L) > 1: # otherwise, no need to sort it marker = L.first() while marker != L.last(): 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 """
def clear(self): """ returns the list to empty. :return: """ self._data = PositionalList()
def clear(self): """Clean the list into empty""" self._data = PositionalList() # will be list of Item instances
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)
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)
""" 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) if __name__ == "__main__": pl = PositionalList() pl.add_first(1) pl.add_first(34) p25 = pl.add_first(25) pl.add_first(35) pl.add_first(40) print([el for el in iter(pl)]) print "the last element in list is %s" % pl.last().element() print "the first element in list is %s" % pl.first().element() print "the element before " print("the element before 25 is %s") % pl.before(p25).element() print("the element after 25 is %s") % pl.after(p25).element() print("Delete the element %s " % pl.delete(p25)) print([el for el in iter(pl)]) print("now Sort the list ..")
def __init__(self) -> None: self._data = PositionalList()
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)
def __init__(self): """Create an empty list of favorites.""" self._data = PositionalList() # will be list of _Item instances
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