Python数据结构与算法分析（第2版）第三章读书笔记

路上6

已于 2023-01-09 20:42:21 修改

阅读量152

点赞数 1

分类专栏： Python数据结构与算法分析（第2版）读书笔记文章标签：数据结构算法

于 2023-01-05 18:36:58 首次发布

本文链接：https://blog.csdn.net/qq_60152842/article/details/128568294

版权

Python数据结构与算法分析（第2版）读书笔记专栏收录该内容

2 篇文章 0 订阅

订阅专栏

线性数据结构包括栈、队列、双端队列和列表。

由于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