线性数据结构包括栈、队列、双端队列和列表。
由于Python内置了列表这一数据结构,使得我们可以用列表来模拟栈、队列、双端队列和链表等数据结构;
一、栈
栈具有"LIFO"这一特性,即数据后进先出。利用栈的这一反转特性,我们可以实现网站URL的前进后退操作,如图1所示:
图1 网站URL的前进后退操作
利用Python的面向对象特性,我们可以通过创建新类来实现栈这种抽象数据结构类型,代码如下:
class Stack:
def __init__(self):
self.items = []
def isEmpty(self):
return self.items == []
def push(self, item):
self.items.append(item)
def pop(self):
return self.items.pop()
def peek(self):
return self.items[len(self.items)-1]
def size(self):
return len(self.items)
栈的反转特性使我们可以进行(大、中、小)括号的匹配,还可以用于进制转换,将十进制转化为二进制等数字,下面给出括号匹配的代码:
def parChecker(symbolString):
s = Stack()
balanced = True
index = 0
print('执行此进程')
while index < len(symbolString) and balanced:
symbol = symbolString[index]
if symbol == "(":
s.push(symbol)
else:
if s.isEmpty():
balanced = False
else:
top = s.pop()
if not matches(top, symbol):
balanced = False
index = index + 1
if balanced and s.isEmpty():
return True
else:
return False
def matches(open, close):
open = "([{"
close = ")]}"
return open.index(open) == close.index(close)
if parChecker('{})'):
print('括号匹配正确')
else:
print('括号匹配错误')
二、队列
队列具有"FIFO"这一特性,即数据先进先出。利用队列的这一特性,可以实现计算机系统控制计算机进程的调度机制。
利用Python的面向对象特性,我们可以通过创建新类来实现队列这种抽象数据结构类型,代码如下:
class Queue:
def __init__(self):
self.items = []
def isEmpty(self):
return self.items == []
def enqueue(self, item):
self.items.insert(0, item)
def dequeue(self):
return self.items.pop()
def size(self):
return len(self.items)
书中给出了用队列来模拟传土豆和打印任务两个例子,现在给出模拟打印任务的代码如下:
class Printer:
def __init__(self, ppm):
self.pagerate = ppm
self.currentTask = None
self.timeRemaining = 0
def tick(self):
if self.currentTask is not None:
self.timeRemaining = self.timeRemaining - 1
if self.timeRemaining <= 0:
self.currentTask = None
def busy(self):
if self.currentTask is not None:
return True
else:
return False
def startNext(self, newtask):
self.currentTask = newtask
self.timeRemaining = newtask.getPages() * 60 / self.pagerate
class Task:
def __init__(self, time):
self.timestamp = time
self.pages = random.randrange(1, 21)
def getStamp(self):
return self.timestamp
def getPages(self):
return self.pages
def waitTime(self, currenttime):
return currenttime - self.timestamp
def simulation(numSeconds, pagesperMinute):
labprinter = Printer(pagesperMinute)
printQueue = Queue()
waitingtimes = []
for currentSecond in range(numSeconds):
if newPrintTask():
task = Task(currentSecond)
printQueue.enqueue(task)
if (not labprinter.busy()) and (not printQueue.isEmpty()):
nexttask = printQueue.dequeue()
waitingtimes.append(nexttask.waitTime(currentSecond))
labprinter.startNext(nexttask)
labprinter.tick()
averageWait = sum(waitingtimes) / len(waitingtimes)
print("Average Wait %6.2f secs %3d tasks remaining." % (averageWait, printQueue.size()))
return averageWait
def newPrintTask():
num = random.randrange(1, 181)
if num == 180:
return True
else:
return False
averageSimulation = 0
for i in range(10):
averageSimulation = averageSimulation + simulation(3600, 10)
print('平均时间为%6.2f' % (averageSimulation/10))
通过改变simulation()函数的参数numSeconds和pagesperMinute可以模拟打印机的不同打印总时间和每分钟打印的页数,但切记如果应用到实际系统中需要获取真实的打印任务数量和学生数目。
三、双端队列
双端队列,同时具有栈和队列的特性,但并不要求按照这两种数据结构分别规定的LIFO原则和FIFO原则操作元素。具体代码如下:
class Deque:
def __init__(self):
self.item = []
def __str__(self):
return str(self.item)
def addFront(self, item):
self.item.append(item)
def addRear(self, item):
self.item.insert(0, item)
def removeFront(self):
return self.item.pop()
def removeRear(self):
return self.item.pop(0)
def isEmpty(self):
return self.item == []
def size(self):
return len(self.item)
书中运用双端队列实现了回文检测器,在书中的代码清单的基础上完成了3.10节的12题,即能够处理字符串出现空格的问题,在此给出具体代码:
def palChecker(aString):
chardeque = Deque()
for ch in aString:
chardeque.addRear(ch)
stillEqual = True
while chardeque.size() > 1 and stillEqual:
first = chardeque.removeFront()
last = chardeque.removeRear()
if first.isspace() or last.isspace():
if first.isspace():
chardeque.addRear(last)
if last.isspace():
chardeque.addFront(first)
else:
if first != last:
stillEqual = False
return stillEqual
print(palChecker('r ad ar '))
四、链表
如前所述,我们都是用Python内置的数据结构去实现其他数据结构,然而,并非所有编程语言都像 Python一样内置了列表这一数据结构,因此我们必须考虑到列表这一数据结构如何实现。
我们首先来看一下列表的定义吧,究竟什么是列表呢?
列表,顾名思义,就是把各种元素列在一个表里,就是元素的集合,其中每一个元素都有一个相对于其他元素的位置,更具体的来说,这种列表称为无序列表。
那么这种无序列表该怎么实现呢?无序列表需要维持元素之间的相对位置,即列表中每一个元素既储存有元素本身的信息,还储存有下一个元素的位置。
需要注意的是,对于这种无序列表(单向列表),必须指明列表中第一个元素的位置。因为只有知道第一个元素的位置,我们才能根据其中的位置关系找到第二个元素,接着找到第三个元素,以此类推,最终找到整个无序列表的元素。
那么,接下来开始实现这种无序列表。
首先,我们需要准备列表中元素的实现,因为它不仅要存储自身的信息,还要存储下一个元素的位置,因此,单个变量肯定是不可以的了,那么我们就要利用Python的面向对象特性去实现这个变量,我们姑且把它叫做节点吧,下面给出节点类的Python的Python代码实现:
class Node:
def __init__(self, initdata):
self.data = initdata
self.next = None
def getData(self):
return self.data
def getNext(self):
return self.next
def setData(self, newdata):
self.data = newdata
def setNext(self, newnext):
self.next = newnext
有了节点类的实现,下面我们就要着眼于无序列表本身的实现了,仿照Python内置的列表这一数据结构的实现,我们复现了无序列表的方法,给出Python代码如下:
class UnorderedList:
def __init__(self):
self.head = None
def isEmpty(self):
return self.head is None
def add(self, item):
temp = Node(item)
temp.setNext(self.head)
self.head = temp
def length(self):
current = self.head
count = 0
while current is not None:
count = count + 1
current = current.getNext()
return count
def search(self, item):
current = self.head
found = False
while self.head is not None and not found:
if current.getData() == item:
found = True
else:
current = current.getNext()
return found
def remove(self, item):
current = self.head
previous = None
found = False
while not found and current is not None:
if current.getData() == item:
found = True
else:
previous = current
current = current.getNext()
if previous is None:
self.head = current.getNext()
else:
previous.setNext(current.getNext())
def append(self, item):
if item is None:
print("没有必要这么做,原因我想你已经知道了")
current = self.head
if current is None:
self.head = Node(item)
else:
while current.getNext() is not None:
current = current.getNext()
current.setNext(Node(item))
def pop(self, pos=""):
current = self.head
previous = None
if pos == "":
if current.getData() is None:
print('没有必要这么做,此时为空链表')
return
while current.getNext() is not None:
previous = current
current = current.getNext()
previous.setNext(None)
else:
if (int(pos)+1) > self.length():
print('给出索引超出链表的最大空间,进程结束')
return
if current.getData() is None:
print("没有必要这么做,此时为空链表")
return
count = 0
found = False
while not found:
if count == pos:
previous.setNext(current.getNext())
found = True
if not found:
previous = current
current = current.getNext()
count = count + 1
return current.getData()
def index(self, item):
"""
美中不足的是未能考虑到item未在UnorderedList类的情况
"""
current = self.head
found = False
count = 0
while not found:
if current.getData() != item:
current = current.getNext()
count = count + 1
else:
return count
def insert(self, pos, item):
current = self.head
previous = None
found = False
count = 0
while not found:
if count == pos:
previous.setNext(Node(item))
Node(item).setNext(current)
found = True
else:
previous = current
current = current.getNext()
count = count + 1