deque双端队列

最新推荐文章于 2023-04-17 17:15:30 发布
最新推荐文章于 2023-04-17 17:15:30 发布
阅读量326 收藏 2
点赞数
分类专栏： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38477351/article/details/105624599
版权

                                     deque双端队列

1、extend()：

    一次性从右端添加多个元素。

# 实现队列，使用deque
from collections import deque


class Queue():
    def __init__(self, value):
        self.items = deque(value)

    def extend(self, value):
        """extend()：一次性从右端添加多个元素"""
        return self.items.extend(value)


if __name__ == "__main__":
    q = Queue([1, 2, 3])
    print("原始queue：",q.items)

    # 一次性从右端添加多个元素
    q.extend([4, 5, 6])
    print("extend()一次性从右端添加多个元素：", q.items)

    # 运行结果：
    # 原始queue： deque([1, 2, 3])
    # extend()一次性从右端添加多个元素： deque([1, 2, 3, 4, 5, 6])

2、append():

    从右端添加一个元素。

class Queue():
    def __init__(self, value):
        self.items = deque(value)

    def append(self, value):
        """append()：从右端添加一个元素"""
        return self.items.append(value)


if __name__ == "__main__":
    q = Queue([1, 2, 3])
    print("原始queue：",q.items)

    # 从右端添加一个元素
    q.append(7)
    print("append()从右端添加一个元素：", q.items)

    # 运行结果:
    # 原始queue： deque([1, 2, 3])
    # append()从右端添加一个元素： deque([1, 2, 3, 7])

3、extendleft():

    从左端添加多个元素，注意是逆序输入。

# 实现队列，使用deque
from collections import deque


class Queue():
    def __init__(self, value):
        self.items = deque(value)

    def extendLeft(self, value):
        """extendleft()：从左端添加多个元素，注意是逆序输入"""
        return self.items.extendleft(value)


if __name__ == "__main__":
    q = Queue([1, 2, 3])
    print("原始queue：",q.items)

    # 从左端添加多个元素，注意是逆序输入
    q.extendLeft([8, 9, 10])
    print("extendleft()从左端添加多个元素，注意是逆序输入：", q.items)
    
    # 运行结果：
    # 原始queue： deque([1, 2, 3])
    # extendleft()从左端添加多个元素，注意是逆序输入： deque([10, 9, 8, 1, 2, 3])

4、appendleft():

    从左端添加一个元素。

# 实现队列，使用deque
from collections import deque


class Queue():
    def __init__(self, value):
        self.items = deque(value)

    def appendLeft(self, value):
        """appendleft()：从左端添加一个元素"""
        return self.items.appendleft(value)


if __name__ == "__main__":
    q = Queue([1, 2, 3])
    print("原始queue：",q.items)

    # 从左端添加一个元素
    q.appendLeft([11, 12])
    print("appendleft()从左端添加一个元素：", q.items)
    
    # 运行结果：
    # 原始queue： deque([1, 2, 3])
    # appendleft()从左端添加一个元素： deque([[11, 12], 1, 2, 3])

5、pop():

    从右端移除元素。

    注意：deque是线程安全的，所以可以在不同的线程中同时从两端移除元素。

# 实现队列，使用deque
from collections import deque


class Queue():
    def __init__(self, value):
        self.items = deque(value)

    def pop(self):
        """
        pop()：从右端移除元素
        注意：deque是线程安全的，所以可以在不同的线程中同时从两端移除元素
        """
        return self.items.pop()


if __name__ == "__main__":
    q = Queue([1, 2, 3])
    print("原始queue：",q.items)

    # pop()：从右端移除元素
    q.pop()
    print("pop()从右端移除元素：", q.items)

    # 运行结果：
    # 原始queue： deque([1, 2, 3])
    # pop()从右端移除元素： deque([1, 2])

6、popleft():

    从左端移除元素。

    注意：deque是线程安全的，所以可以在不同的线程中同时从两端移除元素。

# 实现队列，使用deque
from collections import deque


class Queue():
    def __init__(self, value):
        self.items = deque(value)

    def popLeft(self):
        """
        popleft()：从左端移除元素
        注意：deque是线程安全的，所以可以在不同的线程中同时从两端移除元素
        """
        return self.items.popleft()


if __name__ == "__main__":
    q = Queue([1, 2, 3])
    print("原始queue：",q.items)

    # 从左端移除元素
    q.popLeft()
    print("popleft()从左端移除元素：", q.items)
   
    # 运行结果：
    # 原始queue： deque([1, 2, 3])
    # popleft()从左端移除元素： deque([2, 3])

7、rorate(param):

    旋转移动元素。

    当参数为正整数n，rorate()将向右移动n位，并将队列右端的n个元素移到左端；

    当参数为负数-n时，rorate()将向左移动n位，并将队列左端的n个元素移到右端。

# 实现队列，使用deque
from collections import deque


class Queue():
    def __init__(self, value):
        self.items = deque(value)


    def rotateRight(self, param):
        """
        rorate(param)：旋转移动元素
        当参数为正整数n，rorate()将向右移动n位，并将队列右端的n个元素移到左端
        """
        return self.items.rotate(param)

    def rotateLeft(self, param):
        """
        rorate(param)：旋转移动元素
        当参数为负数-n时，rorate()将向左移动n位，并将队列左端的n个元素移到右端
        """
        return self.items.rotate(param)


if __name__ == "__main__":
    q = Queue([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    print("原始queue：",q.items)

    # 旋转移动元素(右移)
    q.rotateRight(3)
    print("rorate(param)旋转移动元素(右移)：", q.items)

    # 旋转移动元素(左移)
    q.rotateRight(-3)
    print("rorate(param)旋转移动元素(左移)：", q.items)
    
    # 运行结果：
    # 原始queue： deque([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    # rorate(param)旋转移动元素(右移)： deque([8, 9, 10, 1, 2, 3, 4, 5, 6, 7])
    # rorate(param)旋转移动元素(左移)： deque([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

8、count(param):

    统计队列中元素的个数。

# 实现队列，使用deque
from collections import deque


class Queue():
    def __init__(self, value):
        self.items = deque(value)


    def count(self, value):
        """
        count()：统计队列中元素的个数
        """
        return self.items.count(value)


if __name__ == "__main__":
    q = Queue([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    print("原始queue：",q.items)

    # 统计队列中元素的个数
    count = q.count(6)
    print("count()统计队列中元素的个数：", count)
    
    # 运行结果：
    # 原始queue： deque([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    # count()统计队列中元素的个数： 1

9、reverse():

    反转队列。

# 实现队列，使用deque
from collections import deque


class Queue():
    def __init__(self, value):
        self.items = deque(value)


    def reverse(self):
        """
        reverse()：反转队列
        :return:
        """
        return self.items.reverse()


if __name__ == "__main__":
    q = Queue([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    print("原始queue：",q.items)

    # 反转队列
    q.reverse()
    print("reverse()反转队列：", q.items)
    
    # 运行结果：
    # 原始queue： deque([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    # reverse()反转队列： deque([10, 9, 8, 7, 6, 5, 4, 3, 2, 1])

10、deque(maxlen=N):

    deque(maxlen=N)构造函数会新建一个固定大小的队列。

    当新的元素加入并且这个队列已满的时候，最老的元素会被自动移除掉。

# 实现队列，使用deque
from collections import deque


class Queue():
    def __init__(self, value):
        self.items = deque(value)

    def maxlen(self, value):
        """
        deque(maxlen=N)构造函数会新建一个固定大小的队列。
        当新的元素加入并且这个队列已满的时候，最老的元素会被自动移除掉。
        """
        return deque(self.items, maxlen=value)


if __name__ == "__main__":
    q = Queue([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    print("原始queue：",q.items)

    # 新建一个固定大小的队列
    new_queue = q.maxlen(5)
    print("新建一个固定大小的队列：", new_queue)
    new_queue.append(100)
    print("往固定大小的队列中添加新元素：", new_queue)

    # 运行结果：
    # 原始queue： deque([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    # 新建一个固定大小的队列： deque([6, 7, 8, 9, 10], maxlen=5)
    # 往固定大小的队列中添加新元素： deque([7, 8, 9, 10, 100], maxlen=5)

11、判断一个队列是否是空队列：

# 实现队列，使用deque
from collections import deque


class Queue():
    def __init__(self, value):
        self.items = deque(value)


    def empty(self):
        """
        判断队列是否为空队列
        """
        return len(self.items) == 0


if __name__ == "__main__":
    q = Queue([])
    print("原始queue：", q.items)

    # 判断一个队列是否是空队列
    result = q.empty()
    print("是否为空队列：", result)

    # 运行结果：

    # 原始queue： deque([])
    # 是否为空队列： True

 

诗雨时
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python内建collection共5页.pdf.zip
10-30
Python内建collection共5页.pdf.zip
python collections.deque类的extendleft小坑
筱羊冰冰
10-19 448
from collections import deque from icecream import ic a = deque() ic(a) a.extend([1, 2, 3, 4]) ic(a) a.extendleft([-4, -3 ,-2, -1]) ic(a) 我们看一下结果 这里就有一个坑，他extend添加在尾端的顺序和我传入的顺序是相同的，但是我们extendleft在首段添加，可以看到实际顺序和我传入的顺序相反。 看了一下官网，好叭还真有说明： 看了一下stackoverflow
利用python deque的extend特性实现列表元素查重
weixin_30235225的博客
05-28 472
from collections import deque mydquene = deque() mylist = [0,1,1,2,2,3,3,3,3,4,5,6,7,7,8,8,9,10,10,11,22,33,22] mydquene.extend(mylist) for i in set(mylist): n = mydquene.count(i...
deque函数的使用方法
享受当下
02-26 2270
C++中deque函数的使用方法 deque表示双端队列，在STL中，其实现类似vector，支持随机访问。主要区别在于，从deque对象的开始位置插入和删除元素的时间是固定的，而不像vector中那样是线性时间。所以多数操作发生在序列的起始和结尾处，则应考虑使用deque数据结构。此外,为了实现deque两端执行插入和删除操作的时间为固定的这一目的,deque对象的设计比vector对象更为复杂。因此，尽管二者都提供对元素的随机访问和在序列中部指向线性时间的插入和删除操作，但vector容器执行这些操作更
deque的用法
The way of Super God
07-29 318
deque 介绍 Python中的collentions中有一个deque，这个对象类似于list列表，但是使用list存储数据是，按索引访问元素很快，但是插入和删除就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。 但是deque是为了实现插入和删除操作的双向列表，适用于队列和栈： from collection import deque q = deque([]) # 使用deque 必须是可迭代对象 dq = deque(range(10), maxlen=10) # 可以通过
deque-pop_front
迪迦 • 奥特曼
04-24 1059
//////////////////////////////////////// // 2018/04/24 19:57:03 // deque-pop_front #include <iostream> #include <deque> #include <algorithm> using namespace std; templat...
详解Python的collections模块中的deque双端队列结构
09-21
Python的collections模块包含了一个高效的数据结构，叫做deque（双端队列）。deque是double-ended queue的缩写，它提供了一种高效的方式来进行两端插入和删除操作，这比Python内置的list结构更为便捷。deque的设计...
双端队列Deque及Python实现
12-21
双端队列（Deque，全称Double-Ended Queue）是一种线性数据结构，它具有队列的特点，同时允许在队列的两端进行插入和删除操作。这种数据结构的设计使得它在处理某些特定问题时非常高效，例如在需要快速地在两端进行...
设计循环双端队列
12-21
设计循环双端队列 题目 设计实现双端队列。 请不要使用内置的双端队列库。 链接：https://leetcode-cn.com/problems/design-circular-deque/ 思路 题目要求不使用内置的双端队列库，那么可以考虑使用双指针，即队首...
数据结构笔记：双端队列
01-21
双端队列（deque，double-ended queue），是一种具有队列和栈的性质的数据结构。 双端队列中每一端，都可以进行存入和取出，去其中一段，都像一个栈一样。 存取也只限定在两端，不能在中间 双端队列的实现 通过...
java deque.pop_Java ArrayDeque pop()方法
weixin_31211457的博客
02-26 272
Java ArrayDeque pop()方法java.util.ArrayDeque.pop() 此方法从此双端队列表示的堆栈中弹出一个元素。1 语法public E pop()2 参数无3 返回值此方法返回此双端队列的前面的元素。4 示例package com.yiidian;/*** 一点教程网： http://www.yiidian.com*//*** java.util.ArrayDe...
java poll()是什么方法_Java ArrayDeque poll()方法与示例
weixin_36470210的博客
03-02 6132
ArrayDeque类poll()方法poll()方法在java.lang包中可用。poll()方法用于返回此双端队列表示的队列的head元素，但要从此双端队列中移除head元素。poll()方法是一个非静态方法，只能通过类对象访问，如果尝试使用类名称访问该方法，则会收到错误消息。poll()方法在检索此双端队列的head元素时不会引发异常。语法：publicTpoll();参数：它不接受任何...
java deque.pop_Java ArrayDeque pop()用法及代码示例
weixin_29149245的博客
02-26 268
Java中的Java.util.ArrayDeque.pop()方法用于从双端队列弹出一个元素。该元素从双端队列的顶部弹出，并从双端队列中删除。用法:Array_Deque.pop()参数：该方法不带任何参数。返回值：此方法返回在双端队列的前面存在的元素。异常：如果双端队列为空，则抛出NoSuchElementException异常。下面的程序演示了Java.util.ArrayDeque.pop...
java deque.pop_Java - dequeue的介紹及用法
weixin_39969611的博客
02-26 337
閱讀時間: 15分鐘在電腦科學中， dequeue是指a double-ended queue(雙向佇列)，一般簡寫為deque，讀音是 deck)。Dequeue是一種抽象資料型態，dequeue中的每個元素都可以在佇列中的頭部(左邊)或者在尾部(右邊)的位置進行任何元素的新增移除。java.util.Deque interface 是 java.util.Queue interface 的一個...
双端队列Deque的pop与poll方法
HelloKitty_Gaga的博客
10-20 6296
对于同一队列，这俩方法返回结果是一样的，结果没有区别，只是意义上一个代表弹出栈顶元素，一个代表拿出队列的头部元素 Deque<Integer> deque = new LinkedList<>(); deque.add(0); deque.add(1); deque.add(2); // System.out.println(deque.poll()); System.out.println(deque.pop()); 输出结果都是0 ...
Python-pop()和popleft()方法
aaaccc444的博客
04-17 3584
Python-pop()和popleft()函数 字典和集合中的 pop() 方法删除元素是无序的，并且在删除时返回被删除的值。 列表中的 pop() 方法删除元素是有序的，并且在删除时返回被删除的元素。 在使用时，需要根据具体的数据类型和需求选择合适的 pop() 方法。
python进阶学习笔记-双向队列deque
sinat_41395907的博客
05-07 883
列表用作队列 利用 .append 和 .pop 方法，我们可以把列表当作栈或者队列来用（比如，把 .append和 .pop(0) 合起来用，就能模拟栈的“先进先出”的特点）。但是删除列表的第一个元素（抑或是在第一个元素之前添加一个元素）之类的操作是很耗时的，因为这些操作会牵扯到移动列表里的所有元素。 双向队列 collections.deque 类（双向队列）是一个线程安全、可以快速从两端添加...
双端队列(deque
最新发布
11-08
双端队列(deque)是一种具有队列和栈的性质的数据结构，它可以在队列的两端进行插入和删除操作。在Python中，双端队列可以通过collections模块中的deque类来实现。双端队列的应用场景很多，例如可以用来实现“回文词...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值