用数组array实现栈、队列与用链表linked_list实现栈、队列及相应的应用基于python语言(from Goodrich)

Date:2019-07-07

本博客是基于Goodrich的数据结构与算法python语言实现数据的第五章、第六章、第七章的总结：

下面是原始数据中第五章、第六章、第七章的目录：

第五章-基于数组的序列

 5.1 python序列类型

5.2 低层次数组（5.2.1 引用数组  5.2.2 python中的紧凑数组）

5.3 动态数组和摊销（5.3.1 实现动态数组 5.3.2 动态数组的摊销分析  5.3.3 python列表类）

5.4 python序列类型的效率（5.4.1 python的列表和元组类 5.4.2 python的字符串类）

5.5 使用基于数组的序列（5.5.1 为游戏存储高分 5.5.2 为序列排序 5.5.3 简单密码技术）

5.6 多维数据集

第六章 栈、队列和双端队列

6.1 栈（6.1.1 栈的抽象数据类型 6.1.2 简单的基于数组的栈的实现 6.1.3 使用栈实现数据的逆置 6.1.4 括号和HTML标记匹配）

6.2队列 （6.2.1 队列的抽象数据类型 6.2.2 基于数组的队列实现）

6.3 双端队列 （6.3.1 双端队列的抽象数据类型ADT 6.3.2 使用环形数组实现双端队列 6.3.3 python collections模块中的双端队列）

第七章 链表

7.1 单向链表（7.1.1 用单向链表实现栈 7.1.2 用单向链表实现队列）

7.2 循环链表（7.2.1 轮转调度 7.2.2 用循环链表实现队列）

7.3 双向链表（7.3.1 双向链表的基本实现 7.3.2 用双向链表实现双端队列）

7.4 位置列表的抽象数据类型（7.4.1 含位置信息的列表抽象数据类型 7.4.2 双向链表实现）

7.5 位置列表的排序

7.6 案例研究：维护访问频率(7.6.1 使用有序表 7.6.2 启发式动态调整列表)

7.7 基于链表的序列与基于数组的序列

第五章的代码内容：

# 5-1 探索列表长度和底层大小关系的实验
import sys
n = 100
data = []
for k in range(n):
    a = len(data)
    b = sys.getsizeof(data)
    print('length:{0:3d};size in btyes:{1:4d}'.format(a, b))
    data.append(None)

实现动态数组DynamicArray类

# 5-3 使用ctypes模块提供的原始数组实现DynamicArray类
import ctypes
class DynamicArray:
    def __init__(self):
        self._n = 0
        self._capacity = 1
        self._A = self._make_array(self._capacity)

    def __len__(self):
        return self._n

    def __getitem__(self,k):
        if not 0 <= k < self._n:
            raise IndexError('invalid index')
        return self._A[k]

    def append(self, obj):
        if self._n == self._capacity:
            self._resize(2*self._capacity)
        self._A[self._n] = obj
        self._n += 1

    def _resize(self, c):
        B = self._make_array(c)
        for k in range(self._n):
            B[k] = self._A[k]
        self._A = B
        self._capacity = c

    def _make_array(self, c):
        return(c * ctypes.py_object)()
    
# 5-4 测量python列表类增添操作的摊销花费
from time import time
def compute_average(n):
    data = []
    start = time()
    for k in range(n):
        data.append(None)
    end = time()
    return (end - start)/n

# 5-5 向列表中增添元素(DynamicArray类insert方法的实现)
def insert(self, k, value):
    if self._n == self._capacity:
        self._resize(2*self._capacity)
    for j in range(self._n, k, -1):
        self._A[j] = self._A[j-1]  # 所有元素向后移动一个位置，为了value放到第k位置上。
    self.A[k] = value
    self._n += 1

# 5-6 从列表中删除元素(对DynamicArray类的remove方法的一种实现)
def remove(self, value):
    for k in range(self._n):
        if self._A[k] == value:             # 遍历列表，找到value的位置k
            for j in range(k, self._n-1):   # 从k位置后面的元素，全部向前移动一个位置
                self._A[j] = self._A[j+1]
            self._A[self._n-1] = None
            self._n -= 1
            return 
        raise ValueError('value not found')
    
"""
以上的insert函数和remove函数证明了，针对列表的插入元素和删除元素的效率不高，最坏的时间效率是O(n)，
因为需要将k位置后的元素进行前移动或者向后移动。
"""

例子：

 

# 例1：为某款视频游戏存储一列高分项目。5-7 一个简单的GameEntry类的python代码。其中包括返回游戏条目对象的姓名和分数的方法，还返回表示该条目的字符串方法
class GameEntry:
    def __init__(self, name, score):
        self._name = name
        self._score = score

    def get_name(self):
        return self._name

    def get_score(self):
        return self._score

    def __str__(self):
        return '({0},{1})'.format(self._name, self._score)

# 例2：5-8 Scoreboard类的python代码，其中包含一系列有序的分数，这些分数代表GameEntry对象
"""
一个scoreboard对象只能存储一定数量的高分，一旦到达存储的极限，新的分数必须严格大于得分板上最低的‘最高分’
"""
class Scoreboard:
    def __init__(self, capacity=10):
        self._board = [None] * capacity
        self._n = 0

    def __getitem__(self, k):
        return self._board[k]

    def __str__(self):
        return '\n'.join(str(self._board[j]) for j in range(self._n))

    def add(self, entry):
        score = entry.get_score()
        good = self._n < len(self._board) or score > self._board[-1].get_score() # 要么高分板上还有位置，要么分数大于高分板上最后一个元素
        if good:
            if self._n < len(self._board):
                self._n += 1

            j = self._n - 1
            while j > 0 and self._board[j-1].get_score() < score:
                self._board[j] = self._board[j-1]
                j -= 1
            self._board[j] = entry

# 例3：5-10 在列表中执行插入排序的python代码
def insertion_sort(A):
    for k in range(1, len(A)):
        cur = A[k]
        j = k
        while j > 0 and A[j-1] > cur:
            A[j] = A[j - 1]
            j -= 1
        A[j] = cur
"""
插入排序的嵌套循环在最坏的情况下会导致O(n^2)的运行时间。如果数组最初是反序，则工作量最大。另外，如果初始数组已基本排序或
已经完全排序，则插入排序运行时间为O(n),因为内层循环迭代次数很少或者完全没有迭代
"""

# 例4：5-11 凯撒密码的一个完整python类
class CaesarCipher:
    def __init__(self, shift):
        encoder = [None] * 26
        decoder = [None] * 26
        for k in range(26):
            encoder[k] = chr((k+shift) % 26 + ord('A'))
            decoder[k] = chr((k-shift) % 26 + ord('A'))
        self._forward = ''.join(encoder)
        self._backward = ''.join(decoder)

    def encrypt(self, message):
        return self._transform(message, self._forward)

    def decrypt(self, secret):
        return self._transform(secret, self._backward)

    def _transform(self, original, code):
        msg = list(original)
        for k in range(len(msg)):
            if msg[k].isupper():
                j = ord(msg[k]) - ord('A')
                msg[k] = code[j]
        return ''.join(msg)

if __name__ == '__main__':
    cipher = CaesarCipher(3)
    message = "THE EAGLE IS IN PLAY;MEET AT JOE'S."
    coded = cipher.encrypt(message)
    print('Secret:', coded)
    answer = cipher.decrypt(coded)
    print('Message:', answer)


# 例5:三连棋游戏(管理三连棋游戏的完整python类) p144
class TicTacToe:
    def __init__(self):
        self._board = [['']*3 for j in range(3)]
        self._player = 'X'

    def mark(self,i,j):
        if not (0 <= i <= 2 and 0 <= j <= 2):
            raise ValueError('Invalid board position')
        if self._board[i][j] != ' ':
            raise ValueError('Board position occupied')
        if self.winner() is not None:
            raise ValueError('Game is already complete')
        self._board[i][j] = self._player
        if self._player == 'X':
            self._player = 'O'
        else:
            self._player = 'X'

    def _is_win(self,mark):
        """Check whether the board configuration is a win for the given player."""
        board = self._board  # local variable for shorthand
        return (mark == board[0][0] == board[0][1] == board[0][2] or  # row 0
                mark == board[1][0] == board[1][1] == board[1][2] or  # row 1
                mark == board[2][0] == board[2][1] == board[2][2] or  # row 2
                mark == board[0][0] == board[1][0] == board[2][0] or  # column 0
                mark == board[0][1] == board[1][1] == board[2][1] or  # column 1
                mark == board[0][2] == board[1][2] == board[2][2] or  # column 2
                mark == board[0][0] == board[1][1] == board[2][2] or  # diagonal
                mark == board[0][2] == board[1][1] == board[2][0])  # rev diag

    def winner(self):
        """Return mark of winning player, or None to indicate a tie."""
        for mark in 'XO':
            if self._is_win(mark):
                return mark
        return None

    def __str__(self):
        """Return string representation of current game board."""
        rows = ['|'.join(self._board[r]) for r in range(3)]
        return '\n-----\n'.join(rows)

    if __name__ == '__main__':
        game = TicTacToe()
        # X moves:            # O moves:
        game.mark(1, 1);
        game.mark(0, 2)
        game.mark(2, 2);
        game.mark(0, 0)
        game.mark(0, 1);
        game.mark(2, 1)
        game.mark(1, 2);
        game.mark(1, 0)
        game.mark(2, 0)

        print(game)
        winner = game.winner()
        if winner is None:
            print('Tie')
        else:
            print(winner, 'wins')

例4结果：

Secret: WKH HDJOH LV LQ SODB;PHHW DW MRH'V.
Message: THE EAGLE IS IN PLAY;MEET AT JOE'S.

例5结果：

第六章：主要是关于利用数组以及其中的python列表实现栈、队列和双端队列

# 本章内容是利用python列表实现栈和队列，以及使用环形数组实现双端队列。
# 6-1 Empty异常类的定义
class Empty(Exception):
    pass

# 6-2 用python列表作为一个存储实现一个栈:将栈顶定位到数组/列表的末端
class ArrayStack:
    def __init__(self):
        self._data = []
        
    def __len__(self):  # 计算栈的长度
        return len(self._data)

    def is_empty(self):  # 判断栈是否为空
        return len(self._data) == 0
    
    def push(self,e):   # 向栈中增添元素e
        self._data.append(e)
          
    def top(self):  # 返回栈顶元素
        if self.is_empty():
            raise Empty('Stack is empty')
        return self._data[-1]
    
    def pop(self):  # 删除栈顶元素
        if self.is_empty():
            raise Empty('Stack is Empty')
        return self._data.pop()
    
# 例1：使用栈实现数据的逆置 6-3 一个实现一个文件中各行的逆置函数
def reverse_file(filename):
    S = ArrayStack()
    
    origional = open(filename)  # 打开原始文件，并将其写入S栈中，注意删除了每一行的换行符，为了统一标准(最后一行一般是没有换行符的)
    for line in origional:
        S.push(line.rstrip('\n'))
    origional.close()
    
    output = open(filename, 'w')
    while not S.is_empty():
        output.write(S.pop()+'\n')
    output.close()
    
# 例2：分隔符的匹配算法"({[" and ")}]"。6-4 在算术表达式中分隔符匹配算法的函数实现
def is_matched(exper):
    lefty = '({['
    righty = ')}]'
    S = ArrayStack()
    for c in exper:
        if c in lefty:
            S.push(c)
        elif c in righty:
            if S.is_empty():
                return False
            if righty.index(c) != lefty.index(S.pop()):
                return False
    return S.is_empty()

# 例3：标记语言的标签匹配 6-5 测试一个HTML文本是否有匹配标签的函数
def is_matched_html(raw):
    S = ArrayStack()
    j = raw.find('<')
    while j != -1:
        k = raw.find('>',j+1)
        if k == -1:
            return False
        tag = raw[j+1:k]
        if not tag.startswith('/'):
            S.push(tag)
        else:
            if S.is_empty():
                return False
            if tag[1:] != S.pop():
                return False
        j = raw.find('<',k+1)
    return S.is_empty()

此处附上一般的HTML格式：

# 6-6 基于数组的队列的实现
class ArrayQueue:
    DEFAULT_CAPACITY = 10
    
    def __init__(self):
        self._data = [None] * ArrayQueue.DEFAULT_CAPACITY  # 此处定义了3个实例变量
        self._size = 0
        self._front = 0
        
    def __len__(self):  # 计算队列的长度
        return self._size
    
    def is_empty(self):  # 判断队列是否为空
        return self._size == 0
    
    def first(self):  # 返回队列的首尾元素
        if self.is_empty():
            raise Empty('Queue is empty')
        return self._data[self._front]
    
    def dequeue(self):   # 删除队列的元素，注意3个实例变量的改变
        if self.is_empty():
            raise Empty('Queue is empty')
        answer = self._data[self._front]
        self._data[self._front] = None
        self._front = (self._front + 1) % len(self._data)
        self._size -= 1
        return answer
    
    def enqueue(self,e):
        if self._size == len(self._data):
            self._resize(2*len(self._data))
        avail = (self._front + self._size) % len(self._data)
        self._data[avail] = e
        self._size += 1
    
    def _resize(self, cap):
        old = self._data
        self._data = [None] * cap
        walk = self._front
        for k in range(self._size):
            self._data[k] = old[walk]
            walk = (1+walk) % len(old)
        self._front = 0

# 自行实现:使用环形数组实现双端队列

第七章： 引入另一种线性表：链表；然后基于单向链表的栈、队列实现和基于双向链表的双向队列的实现。

虽然数组和链表都是数据结构中的线性表，但是他们有着一些不同，最明显的就是：数组对于索引、查找很快，但对于插入和删除效率不高；链表对于索引、查找效率不高，但对于插入和删除相当高效。他们两者的具体联系与区别可以参考我的另一篇博客：

数组和链表的区别

涉及基于单向链表得到的栈、单向队列；基于循环链表实现循环队列；基于双向链表生成的双端队列；以及几个例子。

class Empty(Exception):
    pass
# 7-5 单向链表实现栈ADT
class LinkedStack:
    """LIFO Stack implementation using a singly linked list for storage."""

    # -------------------------- nested _Node class --------------------------
    class _Node:
        """Lightweight, nonpublic class for storing a singly linked node."""
        __slots__ = '_element', '_next'  # streamline memory usage

        def __init__(self, element, next):  # initialize node's fields
            self._element = element  # reference to user's element
            self._next = next  # reference to next node

    # ------------------------------- stack methods -------------------------------
    def __init__(self):
        """Create an empty stack."""
        self._head = None
        self._size = 0

    def __len__(self):    # 返回现有栈的长度
        return self._size

    def is_empty(self):  # 判断现有栈是否为空
        return self._size == 0

    def push(self, e):   # 在栈顶端插入元素
        self._head = self._Node(e, self._head)
        self._size += 1

    def top(self):       # 返回栈顶端元素
        if self.is_empty():
            raise Empty('Stack is empty')
        return self._head._element

    def pop(self):   # 删除栈顶端元素
        if self.is_empty():
            raise Empty('Stack is empty')
        answer = self._head._element
        self._head = self._head._next
        self._size -= 1
        return answer

# 7-7 用单向链表实现队列ADT
class LinkedQueue:
    class _Node:
        """Lightweight, nonpublic class for storing a singly linked node."""
        __slots__ = '_element', '_next'  # streamline memory usage

        def __init__(self, element, next):  # initialize node's fields
            self._element = element  # reference to user's element
            self._next = next  # reference to next node

        # ------------------------------- queue methods -------------------------------

    def __init__(self):
        """Create an empty queue."""
        self._head = None
        self._tail = None
        self._size = 0

    def __len__(self):     # 计算队列的长度
        return self._size

    def is_empty(self):    # 判断队列是否为空
        return self._size == 0

    def first(self):      # 返回队列的第一个元素
        if self.is_empty():
            raise Empty('Queue is empty')
        return self._head._element

    def dequeue(self):   # 删除队列首元素。首先需要判断是否为空，删除首元素后仍需判断是否为空(如为空，tail=None)
        if self.is_empty():
            raise Empty('Queue is empty')
        answer = self._head._element
        self._head = self._head._next
        self._size -= 1
        if self.is_empty():
            self.tail = None
        return answer

    def enqueue(self,e):
        newest = self._Node(e,None)
        if self.is_empty():
            self._head = newest
        else:
            self.tail._next = newest
        self.tail = newest
        self._size += 1

# 7-9 用循环链表实现循环队列类 (训练队列不需要队首标识，仅仅tail即可)
class CircularQueue:
    class _Node:
        """Lightweight, nonpublic class for storing a singly linked node."""
        __slots__ = '_element', '_next'  # streamline memory usage

        def __init__(self, element, next):  # initialize node's fields
            self._element = element  # reference to user's element
            self._next = next  # reference to next node

    def __init__(self):
        self._tail = None
        self._size = 0

    def __len__(self):   # 计算循环队列的长度
        return self._size

    def is_empty(self):   # 判断循环队列是否为空
        return self._size == 0

    def first(self):     # 返回循环队列的首位元素(tail后的元素)
        if self.is_empty():
            raise Empty('Queue is empty')
        head = self._tail._next
        return head._element

    def dequeue(self):   # 删除循环队列首位元素(tail后的元素),并返回删除的原首位元素的值
        if self.is_empty():
            raise Empty('Queue is empty')
        oldhead = self._tail._next
        if self._size == 1:
            self._tail = None
        else:
            self._tail._next = oldhead._next
        self._size -= 1
        return oldhead._element

    def enqueue(self, e):  # 在循环队列的末尾增添元素，需要：该元素的后置元素设置；tail后置元素的更新；tail标记更新
        newest = self._Node(e, None)
        if self.is_empty():
            newest._next =newest
        else:
            newest._next = self._tail._next
            self._tail._next = newest
        self._tail = newest
        self._size += 1

    def rotate(self):
        if self._size > 0:
            self._tail = self._tail._next


# 7-12 基于双向链表的基类
class _DoublyLinkedBase:
  """A base class providing a doubly linked list representation."""

  #-------------------------- nested _Node class --------------------------
  # nested _Node class
  class _Node:
    """Lightweight, nonpublic class for storing a doubly linked node."""
    __slots__ = '_element', '_prev', '_next'            # streamline memory

    def __init__(self, element, prev, next):            # initialize node's fields
      self._element = element                           # user's element
      self._prev = prev                                 # previous node reference
      self._next = next                                 # next node reference

  #-------------------------- list constructor --------------------------
  def __init__(self):
      self._header = self._Node(None, None, None)  # 头哨兵
      self._tailer = self._Node(None, None, None)   # 尾哨兵
      self._header._next = self._tailer
      self._tailer._prev = self._header
      self._size = 0   # 只有头哨兵和尾哨兵，中间没有任何元素

  #-------------------------- public accessors --------------------------
  def __len__(self):  # 计算长度
      return self._size

  def is_empty(self):  # 判断是否为空
      return self._size == 0

  # -------------------------- nonpublic utilities --------------------------
  def _insert_between(self,e,predecessor,successor):  # 私有程序
      newsest = self._Node(e,predecessor,successor)
      predecessor._next = newsest
      successor._prev = newsest
      self._size += 1
      return newsest

  def _delete_between(self,node):    # 私有程序
      predecessor = node._prev
      successor = node._next
      predecessor._next = successor
      successor._prev = predecessor
      self._size -= 1
      element = node._element
      node._prev = node._next = node._element = None
      return element


# 7-13 继承双向链表基类实现双端队列
from .doubly_linked_base import _DoublyLinkedBase
from ..exceptions import Empty

class LinkedDeque(_DoublyLinkedBase):         # note the use of inheritance
  """Double-ended queue implementation based on a doubly linked list."""

  def first(self):
    """Return (but do not remove) the element at the front of the deque.

    Raise Empty exception if the deque is empty.
    """
    if self.is_empty():
      raise Empty("Deque is empty")
    return self._header._next._element        # real item just after header

  def last(self):
    """Return (but do not remove) the element at the back of the deque.

    Raise Empty exception if the deque is empty.
    """
    if self.is_empty():
      raise Empty("Deque is empty")
    return self._trailer._prev._element       # real item just before trailer

  def insert_first(self, e):
    """Add an element to the front of the deque."""
    self._insert_between(e, self._header, self._header._next)   # after header

  def insert_last(self, e):
    """Add an element to the back of the deque."""
    self._insert_between(e, self._trailer._prev, self._trailer) # before trailer

  def delete_first(self):
    """Remove and return the element from the front of the deque.

    Raise Empty exception if the deque is empty.
    """
    if self.is_empty():
      raise Empty("Deque is empty")
    return self._delete_node(self._header._next)   # use inherited method

  def delete_last(self):
    """Remove and return the element from the back of the deque.

    Raise Empty exception if the deque is empty.
    """
    if self.is_empty():
      raise Empty("Deque is empty")
    return self._delete_node(self._trailer._prev)  # use inherited method

# 7-14 基于双向链表的positionalList类的实现
from .doubly_linked_base import _DoublyLinkedBase

class PositionalList(_DoublyLinkedBase):
    """A sequential container of elements allowing positional access."""

    # -------------------------- nested Position class --------------------------
    class Position:
        """An abstraction representing the location of a single element.

        Note that two position instaces may represent the same inherent
        location in the list.  Therefore, users should always rely on
        syntax 'p == q' rather than 'p is q' when testing equivalence of
        positions.
        """

        def __init__(self, container, node):
            """Constructor should not be invoked by user."""
            self._container = container
            self._node = node

        def element(self):
            """Return the element stored at this Position."""
            return self._node._element

        def __eq__(self, other):
            """Return True if other is a Position representing the same location."""
            return type(other) is type(self) and other._node is self._node

        def __ne__(self, other):
            """Return True if other does not represent the same location."""
            return not (self == other)  # opposite of __eq__

    # ------------------------------- utility methods -------------------------------
    def _validate(self, p):
        """Return position's node, or raise appropriate error if invalid."""
        if not isinstance(p, self.Position):
            raise TypeError('p must be proper Position type')
        if p._container is not self:
            raise ValueError('p does not belong to this container')
        if p._node._next is None:  # convention for deprecated nodes
            raise ValueError('p is no longer valid')
        return p._node

    def _make_position(self, node):
        """Return Position instance for given node (or None if sentinel)."""
        if node is self._header or node is self._trailer:
            return None  # boundary violation
        else:
            return self.Position(self, node)  # legitimate position

    # ------------------------------- accessors -------------------------------
    def first(self):
        """Return the first Position in the list (or None if list is empty)."""
        return self._make_position(self._header._next)

    def last(self):
        """Return the last Position in the list (or None if list is empty)."""
        return self._make_position(self._trailer._prev)

    def before(self, p):
        """Return the Position just before Position p (or None if p is first)."""
        node = self._validate(p)
        return self._make_position(node._prev)

    def after(self, p):
        """Return the Position just after Position p (or None if p is last)."""
        node = self._validate(p)
        return self._make_position(node._next)

    def __iter__(self):
        """Generate a forward iteration of the elements of the list."""
        cursor = self.first()
        while cursor is not None:
            yield cursor.element()
            cursor = self.after(cursor)

    # ------------------------------- mutators -------------------------------
    # override inherited version to return Position, rather than Node
    def _insert_between(self, e, predecessor, successor):
        """Add element between existing nodes and return new Position."""
        node = super()._insert_between(e, predecessor, successor)
        return self._make_position(node)

    def add_first(self, e):
        """Insert element e at the front of the list and return new Position."""
        return self._insert_between(e, self._header, self._header._next)

    def add_last(self, e):
        """Insert element e at the back of the list and return new Position."""
        return self._insert_between(e, self._trailer._prev, self._trailer)

    def add_before(self, p, e):
        """Insert element e into list before Position p and return new Position."""
        original = self._validate(p)
        return self._insert_between(e, original._prev, original)

    def add_after(self, p, e):
        """Insert element e into list after Position p and return new Position."""
        original = self._validate(p)
        return self._insert_between(e, original, original._next)

    def delete(self, p):
        """Remove and return the element at Position p."""
        original = self._validate(p)
        return self._delete_node(original)  # inherited method returns element

    def replace(self, p, e):
        """Replace the element at Position p with e.

        Return the element formerly at Position p.
        """
        original = self._validate(p)
        old_value = original._element  # temporarily store old element
        original._element = e  # replace with new element
        return old_value  # return the old element value
    
    
# 例1：位置列表的排序  # 7-17 在位置列表中执行插入排序的python代码
def insertion_sort(L):
  """Sort PositionalList of comparable elements into nondecreasing order."""
  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              # pivot becomes new marker
      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


# 例子2：利用positionalList类作为存储实现一个收藏夹的列表 # 7-18 FavoritesLise类
from .positional_list import PositionalList

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)


if __name__ == '__main__':
    fav = FavoritesList()
    for c in 'hello. this is a test of mtf':  # well, not the mtf part...
        fav.access(c)
        k = min(5, len(fav))
        print('Top {0}) {1:25} {2}'.format(k, [x for x in fav.top(k)], fav))


# 例子3：启发式动态调整列表，启发式算法尝试利用访问的局部性，就是在访问序列中采用movie-to-front启发式
# 7-20  FavoritesListMTF类实现mtf启发式，继承了FavoritesList和PositionalList
from .favorites_list import FavoritesList
from .positional_list import PositionalList

class FavoritesListMTF(FavoritesList):
  """List of elements ordered with move-to-front heuristic."""

  # we override _move_up to provide move-to-front semantics
  def _move_up(self, p):
    """Move accessed item at Position p to front of list."""
    if p != self._data.first():
      self._data.add_first(self._data.delete(p))       # delete/reinsert

  # we override top because list is no longer sorted
  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

if __name__ == '__main__':
  fav = FavoritesListMTF()
  for c in 'hello. this is a test of mtf':
    fav.access(c)
    k = min(5, len(fav))
    print('Top {0}) {1:25} {2}'.format(k, [x for x in fav.top(k)], fav))