数据结构第四章笔记

数据结构笔记

---

---

第四章

队列抽象数据类型及 python 实现

什么是队列

抽象数据类型 Queue 的操作

队列的实现

对列表末端为队列头的实现，代码如下：

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)

enqueue() 复杂度为 O(n)，dequeue() 复杂度为 O(1)。

队列的应用：热土豆

代码如下：

from QueueDefinition import Queue

def hotPotato(nameList, num):
    q = Queue()
    for name in nameList:
        q.enqueue(name)
        
    while q.size() > 1:
        for i in range(num):
            q.enqueue(q.dequeue())
        q.dequeue()
        
    return q.dequeue()

print(hotPotato(['A','B','C','D','E','F','G'],7))  ==>D

队列的应用：打印任务

问题模拟

对问题建模

模拟流程

代码如下：

# -*- coding: utf-8 -*-
"""
Created on Sat Apr 16 15:01:56 2022

@author: hp
"""

from QueueDefinition import Queue
import random

class Printer:              #实现打印机
    def __init__(self,rate):
        self.pagerate = rate
        self.currentTask = None
        self.timeRemaining = 0
        
    def tick(self):         #打印过程
        if self.currentTask != None:
            self.timeRemaining -= 1
            if self.timeRemaining <= 0 :
                self.currentTask = None
                
    def busy(self):         #是否运行种
        if self.currentTask != 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 newPrintTask():    #触发新任务
    num = random.randrange(1,181)
    if num == 90:    #可以是任意 1~180 的整数
        return True
    else:
        return False
    
def simulation(Seconds,pagesPerMinute):
    labprinter = Printer(pagesPerMinute)
    q = Queue()
    waitingtimes = []
    
    for s in range(Seconds):#开始计时
        if newPrintTask():   #触发新任务
            task = Task(s)  #任务开始时间
            q.enqueue(task)
            
        if (not labprinter.busy()) and (not q.isEmpty()):
            nexttask = q.dequeue()
            waitingtimes.append(nexttask.waitTime(s))
            labprinter.startNext(nexttask)
        
        labprinter.tick()
        
    averageWait = sum(waitingtimes) / len(waitingtimes)
    print('Avereage Wait %6.2f seconds %3d tasks remaining'\
                  %(averageWait,q.size()))
     
for i in range(10):    #每分钟打印 5 页
    simulation(3600,5) 
==>
Avereage Wait 103.62 seconds   0 tasks remaining
Avereage Wait 188.39 seconds   0 tasks remaining
Avereage Wait  58.13 seconds   2 tasks remaining
Avereage Wait 129.17 seconds   0 tasks remaining
Avereage Wait  41.27 seconds   0 tasks remaining
Avereage Wait  51.85 seconds   2 tasks remaining
Avereage Wait 135.50 seconds   2 tasks remaining
Avereage Wait  48.95 seconds   0 tasks remaining
Avereage Wait 117.10 seconds   0 tasks remaining
Avereage Wait  76.43 seconds   0 tasks remaining    

for i in range(10):    #每分钟打印 10 页
	simulation(3600,10)
==>
Avereage Wait  14.14 seconds   0 tasks remaining
Avereage Wait  21.42 seconds   0 tasks remaining
Avereage Wait  25.19 seconds   0 tasks remaining
Avereage Wait   8.62 seconds   0 tasks remaining
Avereage Wait  17.65 seconds   0 tasks remaining
Avereage Wait  11.62 seconds   0 tasks remaining
Avereage Wait  40.44 seconds   0 tasks remaining
Avereage Wait  25.86 seconds   0 tasks remaining
Avereage Wait  12.09 seconds   1 tasks remaining
Avereage Wait  18.33 seconds   0 tasks remaining        

双端队列抽象数据类型及 python 实现

实现一个列表末端为队首的双端队列：

class Deque:
    def __init__(self):
        self.items = []

    def isEmpty(self):
        return self.items == []
    
    def addFront(self,item):
        self.items.append(item)
        
    def addRear(self,item):
        self.items.insert(0,item)
        
    def removeFront(self):
        return self.items.pop()
    
    def removeRear(self):
        return self.items.pop(0)
    
    def size(self):
        return len(self.items)

addFront()/remveFront() 复杂度为 O(1)
addRear()/removeRear() 复杂度为 O(n)

无序表抽象数据类型及 python 实现

列表（无序表） list

这个无序是指列表各个元素的排列与元素的大小是无关的，但各个元素在存储空间中的位置取决于元素在列表中的位置。

采用链表实现无序表

链表实现：节点 Node

代码如下：

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

链表实现：无序表 UnorderedList

为链表创建空表头，代码如下：

class UnorderedList:
    def __init__(self):   
        self.head = None

无序表的链表实现

add() 以及其他方法代码如下：

from NodeDefinition import Node
class UnorderedList:
    def __init__(self):
        self.head = None
        
    def add(self,item):       
        temp = Node(item)     #创建节点
        temp.setNext(self.head)  #链接链表，第一个加入的节点有 temp.getNext() == None 的特性
        self.head = temp      #设置为链表头
        
    def size(self):
        current = self.head
        count = 0
        while current != None:
            count += 1
            current = current.getNext()    
        return count
    
    def search(self,item):
        current = self.head
        found = False
        while current != 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:
            if current.getData() == item:
                found = True
            else:
                previous = current
                current = current.getNext()            
        if previous == None:
            self.head = current.getNext()
        else:
            previous.setNext(current.getNext())
    def pop(self):
        current = self.head
        previous = None
        while current.getNext() != None:
            previous = current
            current = current.getNext()
        if current == None:
            return None
        elif previous == None:
            data = self.head.getData()
            self.head = None
            return data
        else:
            previous.setNext(None)
            return current.getData()       
            
    def append(self,item):
        current = self.head
        while current.getNext() != None:
            current = current.getNext()
        temp = Node(item)
        current.setNext(temp)
        
myList = UnorderedList()
for i in range(10):
    myList.add(i)
print(myList.size())  ==>10
myList.remove(5)
print(myList.size())  ==>9
print(myList.pop())  ==>0  #0 是最先加入进来的，所以在最后面
myList.append(15)
print(myList.pop())  ==>15

有序表抽象数据类型及 python 实现

只讨论用链表的形式实现：

链表实现的算法分析

线性结构小结