python之 栈与队列

Posted 晴晴小可爱的小弟

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python之 栈与队列相关的知识,希望对你有一定的参考价值。

忍不住想报一句粗口“卧槽”这尼玛python的数据结构也太特么方便了吧

想到当初学c语言的数据结构的时候,真的是一笔一划都要自己写出来,这python尼玛直接一个模块就ok

真的是没有对比就没有伤害啊,之前试着用类来模拟栈与队列的时候就感觉,我擦这还挺方便的。

现在直接就可以import了,直接使用函数了,唉,这这这现在只想说一声,

人生苦短,我用python 

当然栈好像没有这个库

.(stacks)是一种只能通过访问其一端来实现数据存储与检索的线性数据结构,具有后进先出(last in first out,LIFO)的特征

我们可以用这张图来说明栈的应用,那么栈呢有以下功能

    def push(self, num):
    # 把一个元素添加到栈的最顶层
    def pop(self):
    # 删除栈最顶层的元素,并返回这个元素
    def peek(self):
    # 返回最顶层的元素,并不删除它
    def isEmpty(self):
    # 判断栈是否为空
    def size(self):
    # 返回栈中元素的个数

我们这里用顺序来实现栈的功能

class Stack(object):
    def __init__(self):
        self.__Stack = []
    def push(self, num):
    # 把一个元素添加到栈的最顶层
        self.__Stack.append(num)
    def pop(self):
    # 删除栈最顶层的元素,并返回这个元素
        return self.__Stack.pop()
    def peek(self):
        return self.__Stack[len(self.__Stack)-1]
    # 返回最顶层的元素,并不删除它
    def isEmpty(self):
        return self.__Stack == []
    # 判断栈是否为空
    def size(self):
        return len(self.__Stack)
    # 返回栈中元素的个数

s = Stack()

当然如果你愿意的话同样可以构成一个链式的栈

队列(queue·)我操,这个就厉害了直接导入一个函数就ok了 

import queue

我们不妨大胆的help一下    help(queue)

就有了这样的东西

我们只需要关注 queue 和lifoqueue(先进先出队列),priorityqueue(优先级队列)

当然一般的queue都是先进后出啦,

 empty(self)
     |      Return True if the queue is empty, False otherwise (not     
            reliable!).
     |      
     |      This method is likely to be removed at some point.  Use 
            qsize() == 0
     |      as a direct substitute, but be aware that either approach 
             risks a race
     |      condition where a queue can grow before the result of 
            empty() or
     |      qsize() can be used.
     |      
     |      To create code that needs to wait for all queued tasks to 
             be
     |      completed, the preferred technique is to use the join() 
            method.
     |  
     |  full(self)
     |      Return True if the queue is full, False otherwise (not 
            reliable!).
     |      
     |      This method is likely to be removed at some point.  Use 
            qsize() >= n
     |      as a direct substitute, but be aware that either approach 
            risks a race
     |      condition where a queue can shrink before the result of 
             full() or
     |      qsize() can be used.
     |  
     |  get(self, block=True, timeout=None)
     |      Remove and return an item from the queue.
     |      
     |      If optional args \'block\' is true and \'timeout\' is None (the 
            default),
     |      block if necessary until an item is available. If \'timeout\' is
     |      a non-negative number, it blocks at most \'timeout\' 
            seconds and raises
     |      the Empty exception if no item was available within that 
            time.
     |      Otherwise (\'block\' is false), return an item if one is 
            immediately
     |      available, else raise the Empty exception (\'timeout\' is 
            ignored
     |      in that case).
     |  
     |  get_nowait(self)
     |      Remove and return an item from the queue without 
            blocking.
     |      
     |      Only get an item if one is immediately available. 
            Otherwise
     |      raise the Empty exception.
     |  
     |  join(self)
     |      Blocks until all items in the Queue have been gotten and 
            processed.
     |      
     |      The count of unfinished tasks goes up whenever an item 
            is added to the
     |      queue. The count goes down whenever a consumer 
            thread calls task_done()
     |      to indicate the item was retrieved and all work on it is 
            complete.
     |      
     |      When the count of unfinished tasks drops to zero, join() 
            unblocks.
     |  
     |  put(self, item, block=True, timeout=None)
     |      Put an item into the queue.
     |      
     |      If optional args \'block\' is true and \'timeout\' is None (the 
             default),
     |      block if necessary until a free slot is available. If \'timeout\' 
            is
     |      a non-negative number, it blocks at most \'timeout\' 
            seconds and raises
     |      the Full exception if no free slot was available within that 
            time.
     |      Otherwise (\'block\' is false), put an item on the queue if a 
             free slot
     |      is immediately available, else raise the Full exception 
            (\'timeout\'
     |      is ignored in that case).
     |  
     |  put_nowait(self, item)
     |      Put an item into the queue without blocking.
     |      
     |      Only enqueue the item if a free slot is immediately 
             available.
     |      Otherwise raise the Full exception.
     |  
     |  qsize(self)
     |      Return the approximate size of the queue (not reliable!).
     |  
     |  task_done(self)
     |      Indicate that a formerly enqueued task is complete.
     |      
     |      Used by Queue consumer threads.  For each get() used 
             to fetch a task,
     |      a subsequent call to task_done() tells the queue that the 
            processing
     |      on the task is complete.
     |      
     |      If a join() is currently blocking, it will resume when all 
            items
     |      have been processed (meaning that a task_done() call 
            was received
     |      for every item that had been put() into the queue).
     |      
     |      Raises a ValueError if called more times than there were 
            items
     |      placed in the queue.        
View Code

好啦这是直接help出来的,总结一下就是

get(self, block=True, timeout=None) # 出队列

put(self, item, block=True, timeout=None) # 进队列 block是堵塞的意思,如果等于false则报错,

task_done(self) # 指示以前加入队列的任务已完成

以上是关于python之 栈与队列的主要内容,如果未能解决你的问题,请参考以下文章

python - 栈与队列(只有代码)

数据结构之栈与队列

数据结构回顾之顺序存储结构中的线性表(栈与队列顺序线性表实现)

数据结构之栈与队列

数据结构 之 栈与队列

3)数据结构之线性表(栈与队列)