python队列和栈

python代码实现栈和队列

两者区别与概念

1. 队列是一种列表，不同的是队列只能在队尾插入元素，在队首删除元素。
   队列是一种先进先出（First-In-First-Out，FIFO）的数据结构。队列被用在很多地方，比如提交操作系统执行的一系列进程、打印任务池等，一些仿真系统用队列来模拟银行或杂货店里排队的顾客。
   
   queue的常用操作：

Queue()        定义一个空队列，无参数，返回值是空队列。
enqueue(item)  在队列尾部加入一个数据项，参数是数据项，无返回值。
dequeue()      删除队列头部的数据项，不需要参数，返回值是被删除的数据，队列本身有变化。
isEmpty()      检测队列是否为空。无参数，返回布尔值。
clear()        清空队列，无参无返回值
size()         返回队列数据项的数量。无参数，返回一个整。

queue的实现代码如下：

class Queue(object):
    #定义一个空队列
    def __init__(self):
        self.items = []
    #队列(只能在队尾)添加一个元素
    def enqueue(self, item):
        self.items.append(item)
    #删除队列（只能在对头）一个元素
    def dequeue(self):
        self.items.pop(0)
    #判断队列是否为空
    def isEmpty(self):
        return(self.items == [])
    #清空队列
    def clear(self):
        del(self.items) #该队列就不存在了，而不是清空元素
    #返回队列项的数量
    def size(self):
        return(len(self.items))
    #打印队列
    def print(self):
        print(self.items)
if __name__ == '__main__':
    q = Queue()
    print(q.isEmpty())
    for i in range(5):
        q.enqueue(i)
    print(q.size())
    q.print()
    q.dequeue()
    q.print()
    q.clear()
    print(q)

2.栈是一种特殊的列表，栈内的元素只能通过列表的一端访问，这一端称为栈顶。咖啡厅内的一摞盘子是现实世界中常见的栈的例子。只能从最上面取盘子，盘子洗净后，也只能摞在这一摞盘子的最上面。
栈被称为一种后入先出（LIFO，last-in-first-out）的数据结构。由于栈具有后入先出的特点，所以任何不在栈顶的元素都无法访问。为了得到栈底的元素，必须先拿掉上面的元素。

stack的常用操作：

class Stack(object):
    #定义一个空栈
    def __init__(self):
        self.items = []
    #添加一个元素
    def push(self, item):
        self.items.append(item)
    #删除一个元素
    def pop(self):
        return(self.items.pop())
    #返回栈顶
    def peek(self):
        return(self.items[-1])
    #清空栈
    def clear(self):
        del(self.items)
    #判断是否为空
    def isEmpty(self):
        return(self.items == [])
    #返回栈中元素个数
    def size(self):
        return(len(self.items))
    #打印栈
    def print(self):
        print(self.items)
if __name__ == '__main__':
    s = Stack()
    print(s.isEmpty())
    for i in range(5):
        s.push(i)
    s.print()
    s.pop()
    s.print()
    print(s.size())
    print(s.peek())
    s.clear()

以上都是用代码解释队列与栈的实现

python队列方法实现

使用python实现队列

from queue import Queue
q = Queue(5)# 创建一个长度为5的队列
print(q.empty()) # 判队空
q.put(1)# 入队：向队列中添加元素
q.put("abc")
q.put([1, 2, 3])
q.put({"a": 123})
q.put((1, 2))
print(q.full())# 判队满
print(q.qsize())# 量队
print(q.get())# 出队：从队列中取出元素
print(q.get())
print(q.get())
print(q.get())
print(q.get())
print(q.empty())# 判断队空
print(q.qsize())# 量队
q.put_nowait(6)# 非阻塞入队
print(q.get_nowait())# 非阻塞出队

使用python实现栈

from queue import LifoQueue
s = LifoQueue(5)# 定义一个5长度的栈
s.put(1)# 进栈：向栈中添加元素
s.put(2)
s.put(3)
s.put(4)
s.put(5)
print(s.full())# 判栈满
print(s.qsize())# 量栈
print(s.get())# 退栈：从栈中取出元素
print(s.get())
print(s.get())
print(s.get())
print(s.get())
print(s.empty())# 判栈空
print(s.qsize())# 量栈

双边队列

简介：
collections 是 python 内建的一个集合模块，里面封装了许多集合类，其中队列相关的集合只有一个：deque。
deque 是双边队列（double-ended queue），具有队列和栈的性质，在 list 的基础上增加了移动、旋转和增删等。
常用方法：
d = collections.deque([])
d.append(‘a’) # 在最右边添加一个元素，此时 d=deque(‘a’)
d.appendleft(‘b’) # 在最左边添加一个元素，此时 d=deque([‘b’, ‘a’])
d.extend([‘c’,‘d’]) # 在最右边添加所有元素，此时 d=deque([‘b’, ‘a’, ‘c’, ‘d’])
d.extendleft([‘e’,‘f’]) # 在最左边添加所有元素，此时 d=deque([‘f’, ‘e’, ‘b’, ‘a’, ‘c’, ‘d’])
d.pop() # 将最右边的元素取出，返回 ‘d’，此时 d=deque([‘f’, ‘e’, ‘b’, ‘a’, ‘c’])
d.popleft() # 将最左边的元素取出，返回 ‘f’，此时 d=deque([‘e’, ‘b’, ‘a’, ‘c’])
d.rotate(-2) # 向左旋转两个位置（正数则向右旋转），此时 d=deque([‘a’, ‘c’, ‘e’, ‘b’])
d.count(‘a’) # 队列中’a’的个数，返回 1
d.remove(‘c’) # 从队列中将’c’删除，此时 d=deque([‘a’, ‘e’, ‘b’])
d.reverse() # 将队列倒序，此时 d=deque([‘b’, ‘e’, ‘a’])
1、可以使用 deque 的旋转来制作跑马灯：

import collections
import sys
import time

def marquee(length=50, speed=1, direction=1):
    """
    生成一个简单的跑马灯
    length:总长
    speed：每0.1秒的移动速度
    direction:0为向左，1为向右
    """
    if direction == 1:
        array = '>'
    else:
        array = '<'
    que = collections.deque([array])
    que.extend(['-'] * (length - 1)) # 形如'>------'
    while True:
        print('%s' % ''.join(que))
        if direction == 1:
            que.rotate(1 * speed)
        else:
            que.rotate(-1 * speed)
        sys.stdout.flush()
        time.sleep(0.1)

if '__main__' == __name__:
    marquee()

""" 约瑟夫算法
据说著名犹太历史学家 Josephus 有过以下的故事：
在罗马人占领桥塔帕特后，39个犹太人与 Josephus 及他的朋友躲到一个洞中，
39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，
由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，
直到所有人都自杀身亡为止。然而 Josephus 和他的朋友并不想自杀，
问他俩安排的哪两个位置可以逃过这场死亡游戏？
"""
import collections
def ysf(a, b):
    d = collections.deque(range(1, a+1)) # 将每个人依次编号，放入到队列中
    while d:
        d.rotate(-b) # 队列向左旋转b步
        print(d.pop()) # 将最右边的删除，即自杀的人

if __name__ == '__main__':
    ysf(41,3) # 输出的是自杀的顺序。最后两个是16和31，说明这两个位置可以保证他俩的安全。