python 数据结构与算法学习笔记（一）线性结构

1.顺序表
2.链表
3.栈
4.队列

线性结构是一种有序数据项的集合，其中每个数据项都有唯一的前驱和后继（除第一个没有前驱，最后一个没有后继）。不同线性结构的关键区别在于数据项增减的方式，有的结构只允许数据从一端添加，而有的结构则允许数据从两端移除。不同的方式形成了不同的线性结构，如栈（Stack）、队列（Queue）、双端队列（Deque）和列表（List）。

1. 顺序表

（1）连续存储与顺序表
计算机内部存储的本质是将是将所需要存储的数据类型转换为二进制表示，并存储在基本存储单元中（字节），1字节=8位，不同的数据类型所占用的内存大小不同，如32位计算机中，基本int占4个字节，char占1个字节。存储在基本单元中的数据都是0、1，需要通过存储时声明的数据类型，确认在取出时是当作int或char处理。
连续存储的概念是，定义一个有顺序的数据集合，如List = [2,54,13,31]，在存储时（假设一个数字占4个字节），将各个数字转换为二进制数据，在创建List集合时，集合指向的内存地址为起始位置0x17，对于第0个元素则以0x17标记，由于一个数字占4个字节，那么下一个数字存储的内存地址为0x17+41=0x21，此后依次类推（起始地址+下标数据类型所占字节数）。

如上所述，在内存中以连续的存储空间来存储的数据集合，即为顺序表。在顺序表中，数据的取出，按照起始地址+下标数据类型所占字节数来索引。但这仅是顺序表中数据类型一致时，如果顺序表中数据类型不一致，由于不同数据类型所占内存大小不一，所以不能直接将其按顺序存储，因为这样会导致无法推算某个下标对应的内存地址。所以在顺序表做指向的内存中不直接存储数据，而是存储指向存储数据的地址：

（2）顺序表的结构与实现*
顺序表在实现时，除了数据存储空间，一般还需要添加一个表头来存储顺序表的信息（顺序表内存多大、现在存储了多少）。顺序表实现的两种基本方式是一体式结构（表头和存储空间连续）和分离式结构（表头和存储空间分离，表头最后一个内存存储了指向存储空间的地址）：

在实现过程中一般采用分离式结构，以免顺序表在变换或扩充时，重新申请内存导致顺序表指向表头的地址变化。同时在扩充时一般采用两种策略：①增加固定内存；②每次在前面的基础上翻倍。
（3）顺序表的操作
①增加元素：

②删除元素时间复杂度同上

2. 链表

2.1 单链表

很明显，顺序表存在一个问题，在进行扩充时，如果当前内存不足，需要重新申请内存，将原内存存储迁移过去，这样会同时造成时间（复制）和空间（再次申请内存时预留）的浪费。那么能否实现这样一个表，保留顺序表索引的特性，同时，在扩充时，动态的申请内存直接添加呢？
（1）链表的结构
链表就能够实现这样的功能，存储一个元素的区域不再是一个元素的大小，还需要包含一个内存区域来存储指向下一个元素的地址：

（2）python中地址的指向
在python中，创建一个变量a = 10，a并不像是C一样是指存储10的内存的别名，也无法像C一样创建一个指针变量来指向一个地址。python中的变量名实际上保存的是指向保存10的内存的地址。所以在python中很方便的可以实现链表结构，通过直接创建一个变量即可作为指向一块内存的地址。
（3）链表的实现
通过python实现List，链表结构如下：

（4）单链表与顺序表的对比
①链表失去了顺序表随机读取的优点，同时由于链表还需要存储地址，空间开销大，但存储空间灵活；
②在删除和插入操作中，链表主要是遍历耗时，删除和插入都是O(1)的；而顺序表遍历查找很快，但拷贝覆盖耗时。

单向链表代码：

# coding:utf-8

class Node(object):

    def __init__(self,elem = None):
        self.elem = elem
        self.next = None

class SingleLinkList(object):
    """single Link list"""
    def __init__(self):
        self.__head = None

    def is_empty(self):
        """confirm whether the list is empty"""
        return self.__head == None

    def length(self):
        """the length of list"""
        cur = self.__head
        count = 0
        while cur != None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        """travel the list,and print the every value of the list"""
        print("[",end=" ")
        cur = self.__head
        while cur != None:
            print(cur.elem,end = ", ")
            cur = cur.next

        print("]",end=" ")

    def add(self,elem):
        """add element into the head of list"""
        node = Node(elem)
        node.next = self.__head
        self.__head = node

    def append(self,elem):
        """add element into the tail of list"""
        node = Node(elem)
        if self.is_empty():
            self.__head = node
        else:
            cur = self.__head
            while cur.next != None:
                cur = cur.next

            cur.next = node

    def insert(self,pos,elem):
        """insert element into the specific index position of list"""
        if pos <= 0:
            self.add(elem)
        elif pos > self.length() - 1:
            self.append(elem)
        else:
        
            node = Node(elem)
            pre = self.__head
            count = 0
            while count < pos - 1:
                count += 1
                pre = pre.next
            node.next = pre.next
            pre.next = node
            

    def remove(self,elem):
        """remove a element that is found first"""
        if self.is_empty():
            return "empty list"
        else:
            cur = self.__head
            pre = None
            while cur != None:
                if cur.elem == elem:
                    if cur == self.__head:
                        self.__head = cur.next
                        
                    else:
                        pre.next = cur.next
                        cur.next = None
                    return
                else:
                    pre = cur
                    cur = cur.next



    def search(self,elem):
        """confirm whether the element is exist"""
        if self.is_empty():
            return "empty list"
        else:
            cur = self.__head
            while cur != None:
                if cur.elem == elem:
                    return True
                else:
                    cur = cur.next
            return False


if __name__ == "__main__":
    ll = SingleLinkList()
    print("the list is empty:",ll.is_empty())
    print("the length of empty list:",ll.length())

    ll.append(1)
    print("the list is empty:",ll.is_empty())
    print("the length of  list:",ll.length())


    ll.append(2)
    ll.append(3)
    ll.append(4)
    ll.append(5)
    ll.append(6)

    print("---1 2 3 4 5 6---------------------")
    print("---88 7 1 16 2 3 4 5 6---------------------")
    ll.add(7)
    ll.insert(-1,88)
    ll.insert(3,16)
    ll.travel()
    print()
    print("------------------------------")
    print(ll.search(3))
    ll.remove(16)
    ll.travel()
    print()
    ll.remove(88)
    ll.travel()
    print()
    ll.remove(6)
    ll.travel()

2.2 单向循环链表

单向循环链表与单链表结构上的唯一区别就是尾结点不再指向None，而是指向头节点，形成一个闭环。
代码实现：

# coding:utf-8

class Node(object):

    def __init__(self,elem = None):
        self.elem = elem
        self.next = None

class SingleLinkList(object):
    """single Link list"""
    def __init__(self,node = None):
        self.__head = node
        if node:
            node.next = node

    def is_empty(self):
        """confirm whether the list is empty"""
        return self.__head == None

    def length(self):
        """the length of list"""
        if self.is_empty():
            return 0
        cur = self.__head
        count = 1
        while cur.next != self.__head:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        """travel the list,and print the every value of the list"""
        print("[",end=" ")
        if self.is_empty():
            print("",end = "")
        else:
            cur = self.__head
            while cur.next != self.__head:
                print(cur.elem,end = ", ")
                cur = cur.next
            print(cur.elem,end = " ")
        print("]",end = " ")

    def add(self,elem):
        """add element into the head of list"""
        node = Node(elem)
        if self.is_empty():
            self.__head = node
            node.next = node
        else:
            cur = self.__head
            while cur.next != self.__head:
                cur = cur.next
            node.next = self.__head
            self.__head = node
            cur.next = self.__head

    def append(self,elem):
        """add element into the tail of list"""
        node = Node(elem)
        if self.is_empty():
            self.__head = node
            node.next = self.__head
        else:
            cur = self.__head
            while cur.next != self.__head:
                cur = cur.next
            cur.next = node
            node.next = self.__head

    def insert(self,pos,elem):
        """insert element into the specific index position of list"""
        if pos <= 0:
            self.add(elem)
        elif pos > self.length() - 1:
            self.append(elem)
        else:
        
            node = Node(elem)
            pre = self.__head
            count = 0
            while count < pos - 1:
                count += 1
                pre = pre.next
            node.next = pre.next
            pre.next = node
            

    def remove(self,elem):
        """remove a element that is found first"""
        if self.is_empty():
            return "empty list"
        else:
            cur = self.__head
            pre = None
            while cur.next != self.__head:
                if cur.elem == elem:
                    #head node
                    if cur == self.__head:
                        tail = self.__head
                        while tail != self.__head:
                            tail = tail.next
                        self.__head = cur.next
                        tail.next = self.__head
                        
                    else:
                    #median node
                        pre.next = cur.next
                        cur.next = None
                    return
                else:
                    pre = cur
                    cur = cur.next
            #tail node
            if cur.elem == elem:
                if cur == self.__head:
                    self.__head = None
                else:
                    pre.next = self.__head
                    cur.next = None

    def search(self,elem):
        """confirm whether the element is exist"""
        if self.is_empty():
            return "empty list"
        else:
            cur = self.__head
            while cur.next != self.__head:
                if cur.elem == elem:
                    return True
                else:
                    cur = cur.next
            if cur.elem == elem:
                return True
            return False


if __name__ == "__main__":
    ll = SingleLinkList()
    print("the list is empty:",ll.is_empty())
    print("the length of empty list:",ll.length())

    ll.append(1)
    print("the list is empty:",ll.is_empty())
    print("the length of  list:",ll.length())


    ll.append(2)
    ll.append(3)
    ll.append(4)
    ll.append(5)
    ll.append(6)

    print("---1 2 3 4 5 6---------------------")
    print("---88 7 1 16 2 3 4 5 6---------------------")
    ll.add(7)
    ll.insert(-1,88)
    ll.insert(3,16)
    ll.travel()
    print()
    print("------------------------------")
    print(ll.search(3))
    ll.remove(16)
    ll.travel()
    print()
    ll.remove(88)
    ll.travel()
    print()
    ll.remove(6)
    ll.travel()

2.3 双向链表

双向链表的节点，除头节点和尾节点，每个节点都会指向前驱节点和后继节点：

代码实现

# coding:utf-8

class Node(object):

    def __init__(self,elem = None):
        self.elem = elem
        self.next = None
        self.prev = None

class DoubleLinkList(object):
    """single Link list"""
    def __init__(self):
        self.__head = None

    def is_empty(self):
        """confirm whether the list is empty"""
        return self.__head == None

    def length(self):
        """the length of list"""
        cur = self.__head
        count = 0
        while cur != None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        """travel the list,and print the every value of the list"""
        print("[",end=" ")
        cur = self.__head
        while cur != None:
            print(cur.elem,end = ", ")
            cur = cur.next

        print("]",end=" ")

    def add(self,elem):
        """add element into the head of list"""
        node = Node(elem)
        node.next = self.__head
        self.__head.prev = node
        self.__head = node


    def append(self,elem):
        """add element into the tail of list"""
        node = Node(elem)
        if self.is_empty():
            self.__head = node
        else:
            cur = self.__head
            while cur.next != None:
                cur = cur.next

            cur.next = node
            node.prev = cur

    def insert(self,pos,elem):
        """insert element into the specific index position of list"""
        if pos <= 0:
            self.add(elem)
        elif pos > self.length() - 1:
            self.append(elem)
        else:
        
            node = Node(elem)
            cur = self.__head
            count = 0
            while count < pos:
                count += 1
                cur = cur.next
            node.next = cur
            node.prev = cur.prev
            cur.prev.next = node
            cur.prev = node

    def remove(self,elem):
        """remove a element that is found first"""
        if self.is_empty():
            return "empty list"
        else:
            cur = self.__head
            while cur != None:
                if cur.elem == elem:
                    if cur == self.__head:
                        self.__head = cur.next
                        if cur.next:
                            cur.next.prev = None
                            cur.next = None
                    else:
                        if cur.next is None:
                            cur.prev.next = None
                            cur.prev = None
                        else:
                            cur.prev.next = cur.next
                            cur.next.prev = cur.prev
                            cur.next = None
                            cur.prev = None
                    return
                else:
                    cur = cur.next



    def search(self,elem):
        """confirm whether the element is exist"""
        if self.is_empty():
            return "empty list"
        else:
            cur = self.__head
            while cur != None:
                if cur.elem == elem:
                    return True
                else:
                    cur = cur.next
            return False


if __name__ == "__main__":
    ll = DoubleLinkList()
    print("the list is empty:",ll.is_empty())
    print("the length of empty list:",ll.length())

    ll.append(1)
    print("the list is empty:",ll.is_empty())
    print("the length of  list:",ll.length())


    ll.append(2)
    ll.append(3)
    ll.append(4)
    ll.append(5)
    ll.append(6)

    print("---1 2 3 4 5 6---------------------")
    print("---88 7 1 16 2 3 4 5 6---------------------")
    ll.add(7)
    ll.insert(-1,88)
    ll.insert(3,16)
    ll.travel()
    print()
    print("------------------------------")
    print(ll.search(3))
    ll.remove(16)
    ll.travel()
    print()
    ll.remove(88)
    ll.travel()
    print()
    ll.remove(6)
    ll.travel()

2. 栈

栈（Stack）是一种有序的数据项集合，在栈中，数据项的加入和移除都发生在同一端（操作端叫栈顶）。距离栈底越近的数据，停留在栈中的时间越长，新加入的数据则会被最先移除，即后进先出。栈相当于对链表(顺序表)进行了限制，不能任意删除、插入，而只能在一端删除添加。
通过python内置List实现栈功能：

# coding:utf-8

class My_stack(object):
    def __init__(self):
        self.__list = []
        
    def push(self,item):
        self.__list.append(item)

    def pop(self):
        return self.__list.pop()

    def peek(self):
        if self.__list:
            return self.__list[-1]
        else:
            return None

    def is_empty(self):
        return self.__list == []

    def size(self):
        return len(self.__list)


if __name__ == "__main__":
    s = My_stack()
    print(s.is_empty())
    s.push(1)
    s.push(2)
    s.push(3)
    s.push(4)
    s.push(5)
    s.push(6)
    print(s.size())
    print(s.peek())
    print(s.pop())
    print(s.size())

（1）栈的应用：简单括号匹配
在数值计算或者代码中括号（（、{、]）都是成对出现的，且嵌套出现，如如果出现非成对或非嵌套形式将会导致出错，如()())、(([)])都是错误的括号匹配方式。那么如何实现括号的正确匹配呢？算法的流程是，从左往右扫描，遇到左括号就压入栈，遇到右括号则判断栈是否为空，不为空则移除栈顶数据，为空则匹配失败。当扫描完成后，判断栈空，栈空则匹配成功，栈不空则匹配失败。

# coding:utf-8

import sys
sys.path.append('./')
import my_stack as Stack

def par_checker(symbol_str):
    s = Stack.My_stack()
    balanced = True
    index = 0

    while index < len(symbol_str) and balanced:
        symbol = symbol_str[index]
        if symbol in "([{":
            s.push(symbol)
        elif symbol in ")]}" :
            if s.is_empty():
                balanced = False
            else:
                temp = s.peek()
                if matches(temp,symbol):
                    s.pop()
                else:
                    balanced = False

        index += 1

    if balanced and s.is_empty():
        return True
    else:
        return False

def matches(open_s,close_s):
    opens = list("([{")
    closes = list(")]}")
    return opens.index(open_s) == closes.index(close_s)


if __name__ == "__main__":
    print(par_checker('(([({})]))'))
    print(par_checker('((([)]))'))
    print(par_checker('(5+3)*2+(2-(3+1))'))

（2）栈的应用：十进制转化为二进制
进制之间的转换就是将数字除以目标进制数，循环求余数，所有余数排列即为转化后的数字，先求出的余数在低位排列，类似栈的先进后出，所以通过栈来实现：

# coding:utf-8

import sys
sys.path.append('./')

import my_stack as Stack

def divide_by2(d_num):
    remstack = Stack.My_stack()

    while d_num > 0:
        rem = d_num % 2
        remstack.push(rem)
        d_num = d_num // 2

    binary_str = ""

    while not remstack.is_empty():
        binary_str = binary_str + str(remstack.pop())
    
    return binary_str

if __name__ == "__main__":
    print(divide_by2(42))

（3）栈的应用：表达式转换
通常我们看到的计算表达式是中缀表示法，中缀表示法对于人来说比较好理解，但是如果不加括号、算符优先级问题，极其容易引起混淆。但对于计算机而言，最好是能明确规定所有计算顺序，而不用处理优先级问题。
所以，引入了前缀和后缀表示法，这两种方法只有一个规则：操作符只与其最近的两个操作数进行计算（前缀为符号及其邻近后两位操作数，后缀为前两位）。这两种方法不用考虑优先级问题。实现中缀表达式转化为前缀（后缀）表达式算法：
①首先将中缀表达式转换为全括号形式（如5+2*3+4 → （5+（2*3）+4））
②按照下述方法移动操作符，并去除括号

转换为后缀表达式：
①创建一个栈来存储符号，从左向右读取每个字符（数字、字母、符号、括号）
②如果读取到字母或数字，直接追加到输出列表中
③如果读取到左括号，压入栈中
④如果读取到右括号：读取栈顶符号，如果不是左括号，就一直弹出栈中元素，直到栈顶为左括号
⑤如果是操作符：判断栈不为空时，栈顶操作符优先级是否大于等于当前读取到符号，如果大于等于，循环弹出栈顶优先级高的操作符；再将当前符号压入栈
⑥最后判断栈是否为空，不空则依次弹出栈，追加至输出列表

# coding:utf-8

import sys
sys.path.append('./')

import my_stack as Stack

def infix2postfix(infixexpr):
    #define priorities
    prec = {}
    prec["*"] = 3
    prec["/"] = 3
    prec["+"] = 2
    prec["-"] = 2
    prec["("] = 1

    op_stack = Stack.My_stack()
    postfix_list = []
    token_list = infixexpr.split()

    # travel expression
    for token in token_list:
        if token in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" or token in "0123456789":
            postfix_list.append(token)
        elif token == "(":
            op_stack.push(token)
        elif token == ")":
            top_token = op_stack.pop()
            while top_token != "(":
                postfix_list.append(top_token)
                top_token = op_stack.pop()
        else:
            while (not op_stack.is_empty()) and (prec[op_stack.peek()] >= prec[token]):
                postfix_list.append(op_stack.pop())
            op_stack.push(token)

    while not op_stack.is_empty():
        postfix_list.append(op_stack.pop())

    return "".join(postfix_list)

if __name__ == "__main__":
    s = "( ( ( A + 3 ) * B ) + ( 6 / C ) )"
    ss = "A + 3 * C + 6 / C"
    print(s)
    print(ss)
    print("---------")

    print(infix2postfix(s))
    print(infix2postfix(ss))

（4）栈的应用：后缀表达式求值
算法：从左向右扫描，如果是数字则压入栈，遇到符号则取出两个数字进行运算（先取出来的数字在算符右边），运算结果压回栈。

# coding:utf-8

import sys
sys.path.append("./")

import my_stack as Stack

def post_eval(postfix_expr):
    op_num_stack = Stack.My_stack()
    token_list = postfix_expr.split()

    for token in token_list:
        
        if token not in "*/+-":
            token = int(token)
            op_num_stack.push(token)
        else:
            op2 = op_num_stack.pop()
            op1 = op_num_stack.pop()
            result = math_op(token,op1,op2)
            op_num_stack.push(result)
    return op_num_stack.pop()
            

def math_op(op,op1,op2):
    if op == "*":
        return op1 * op2
    elif op == "/":
        return op1 / op2
    elif op == "+":
        return op1 + op2
    elif op == "-":
        return op1 - op2

if __name__ == "__main__":
    ops = "32 4 + 6 * 7 8 / +"
    print(post_eval(ops))
    print("---------")
    print("(((32+4)*6)+(7/8) = ",(((32+4)*6)+(7/8)))

3. 队列

队列（Queue）也是一种线性表，但只允许在一段插入，另一端进行删除的操作，即先进先出。
（1）队列实现

# coding:utf-8

class Queue(object):
    def __init__(self):
        self.__list = []

    def enqueue(self,item):
        self.__list.append(item)

    def dequeue(self):
        return self.__list.pop(0)

    def is_empty(self):
        return self.__list == []

    def size(self):
        return len(self.__list)

if __name__ == "__main__":
    q = Queue()
    print(q.is_empty())
    print(q.size())
    q.enqueue(1)
    q.enqueue(2)
    q.enqueue(3)
    q.enqueue(4)
    q.enqueue(10)
    print(q.dequeue())
    print(q.size())

（2）双端队列实现
双端队列即允许两端插入和取出

# coding:utf-8

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

    def add_head(self,item):
        self.__list.insert(0,item)

    def add_tail(self,item):
        self.__list.append(item)

    def remove_head(self):
        return self.__list.pop(0)

    def remove_tail(self):
        return self.__list.pop()

    def is_empty(self):
        return self.__list == []

    def size(self):
        return len(self.__list)

if __name__ == "__main__":
    d = Deque()
    print(d.is_empty())
    print(d.size())
    d.add_head(1)
    d.add_tail(2)
    d.add_head(3)
    d.add_head(4)
    d.add_tail(5)
    d.add_tail(6)
    print(d.remove_head())
    print(d.size())
    print(d.remove_tail())
    print(d.size())

（3）队列的应用：热土豆
热土豆问题也叫约瑟夫问题：传烫手的热土豆，鼓声停止时，手里有土豆的人出列；如果去掉鼓，改为传过固定人数，就出列，即约瑟夫问题。也就是一圈人，某个人开始数数，假设数到7的人出列。通过队列的可以实现这样的功能，每次从队首取出一个人，并计数，没有计数为7的人从队尾入队列，计数为7则不入队列，一直循环，直到只剩下一个人。

# coding:utf-8

import sys
sys.path.append('./')

import Queue

def hot_patato(namelist,num):
    name_queue = Queue.Queue()
    for name in namelist:
        name_queue.enqueue(name)

    while name_queue.size() > 1:
        for i in range(num):
            name_queue.enqueue(name_queue.dequeue())
        name_queue.dequeue()

    return name_queue.dequeue()

if __name__ == "__main__":
    ll = ["A","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S"]
    print(hot_patato(ll,7))

（4）队列的应用：打印任务
当多人共享一台打印机时，采取先到先服务的队列策略来执行打印任务。在这种设定下，首要的问题是：打印作业系统的容量有多大？在能够接受的等待时间内，系统能容纳多少用户以多高频率提交多少打印任务？
问题背景设置：

对问题进行抽象：
①打印机属性：
i、私有字段：打印速度、当前是否有打印任务、当前任务所需剩余时间
ii、打印机功能（方法）：执行打印1秒、打印机是否空闲、是否开始下个任务
②打印任务属性：
i、私有字段：生成打印任务的时间、打印任务页数
ii、任务方法：获取生成时间、获取打印页数、计算生成时间至开始打印本任务的等待时间
③打印流程模拟（设置打印时间范围和打印速度）：
i、初始化打印机、打印队列、等待时间表
ii、在打印时间内，每1秒需要执行：
a、是否生成了打印任务，如果生成了，加入打印队列
b、打印机是否忙且队列是否为空，若打印机空闲且队列不空，则开始打印下一任务，同时计算这个任务在开始打印时间与生成这个任务时的时间差
c、执行1秒打印
注：
①打印任务的生成：一共10人，每小时每次提交2次任务，则每一秒提交任务的概率为20/3600=1/180；
②打印任务页数随机1-20，所以每次生成任务时，随机生成页数。

# coding:utf-8

import sys
sys.path.append('./')

import random
import Queue

class Printer:
    def __init__(self,ppm):
        self.__pagerate = ppm #print speed
        self.__current_task = None
        self.__time_remaining = 0

    def tick(self):
        if self.__current_task != None:
            self.__time_remaining = self.__time_remaining - 1
            if self.__time_remaining <= 0:
                self.__current_task = None

    def busy(self):
        if self.__current_task != None:
            return True
        else:
            return False

    def start_next(self,new_task):
        self.__current_task = new_task
        self.__time_remaining = new_task.get_pages() * 60 / self.__pagerate

class Task:
    def __init__(self,time):
        self.__timestamp = time
        self.__pages = random.randrange(1,21)

    def get_stamp(self):
        return self.__time_stamp

    def get_pages(self):
        return self.__pages

    def wait_time(self,current_time):
        return current_time - self.__timestamp

def new_print_task():
    num = random.randrange(1,181)
    if num == 111:
        return True
    else:
        return False

def simulation_print(num_seconds,pages_per_minute):
    lab_printer = Printer(pages_per_minute)
    print_queue = Queue.Queue()
    waiting_times = []

    for current_time in range(num_seconds):

        if new_print_task():
            task = Task(current_time)
            print_queue.enqueue(task)

        if (not lab_printer.busy()) and (not print_queue.is_empty()):
            next_task = print_queue.dequeue()
            waiting_times.append(next_task.wait_time(current_time))
            lab_printer.start_next(next_task)

        lab_printer.tick()

    ave_waiting_time = sum(waiting_times)/len(waiting_times)
    print("Print task within %d hours,averge wait %6.2f secs,%3d tasks remaining"\
            %(num_seconds/3600,ave_waiting_time,print_queue.size()))

if __name__ == "__main__":
    print("ppm 10:")
    for i in range(10):
        simulation_print(3600,10)
    print("ppm 5:")
    for i in range(10):
        simulation_print(3600,5)

最后编辑于：2020.04.23 11:30:07

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 159,117评论 4赞 362
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 67,328评论 1赞 293
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 108,839评论 0赞 243
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 44,007评论 0赞 206
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 52,384评论 3赞 287
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 40,629评论 1赞 219
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 31,880评论 2赞 313
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 30,593评论 0赞 198
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 34,313评论 1赞 243
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 30,575评论 2赞 246
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 32,066评论 1赞 260
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 28,392评论 2赞 253
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 33,052评论 3赞 236
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 26,082评论 0赞 8
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 26,844评论 0赞 195
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 35,662评论 2赞 274
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 35,575评论 2赞 270