LeetCode 641. 设计循环双端队列

已于 2024-08-20 13:32:14 修改
阅读量577 收藏 7
点赞数 27
文章标签： leetcode 算法 java 职场和发展 数据结构 python 链表
于 2024-08-20 13:31:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56090828/article/details/141354174
版权

641. 设计循环双端队列

设计实现双端队列。

实现 MyCircularDeque 类:

  • MyCircularDeque(int k) ：构造函数,双端队列最大为 k 。
  • boolean insertFront()：将一个元素添加到双端队列头部。 如果操作成功返回 true ，否则返回 false 。
  • boolean insertLast() ：将一个元素添加到双端队列尾部。如果操作成功返回 true ，否则返回 false 。
  • boolean deleteFront() ：从双端队列头部删除一个元素。 如果操作成功返回 true ，否则返回 false 。
  • boolean deleteLast() ：从双端队列尾部删除一个元素。如果操作成功返回 true ，否则返回 false 。
  • int getFront() )：从双端队列头部获得一个元素。如果双端队列为空，返回 -1 。
  • int getRear() ：获得双端队列的最后一个元素。 如果双端队列为空，返回 -1 。
  • boolean isEmpty() ：若双端队列为空，则返回 true ，否则返回 false  。
  • boolean isFull() ：若双端队列满了，则返回 true ，否则返回 false 。

示例 1：

输入
["MyCircularDeque", "insertLast", "insertLast", "insertFront", "insertFront", "getRear", "isFull", "deleteLast", "insertFront", "getFront"]
[[3], [1], [2], [3], [4], [], [], [], [4], []]
输出
[null, true, true, true, false, 2, true, true, true, 4]

解释
MyCircularDeque circularDeque = new MycircularDeque(3); // 设置容量大小为3
circularDeque.insertLast(1);			        // 返回 true
circularDeque.insertLast(2);			        // 返回 true
circularDeque.insertFront(3);			        // 返回 true
circularDeque.insertFront(4);			        // 已经满了，返回 false
circularDeque.getRear();  				// 返回 2
circularDeque.isFull();				        // 返回 true
circularDeque.deleteLast();			        // 返回 true
circularDeque.insertFront(4);			        // 返回 true
circularDeque.getFront();				// 返回 4

提示：

  • 1 <= k <= 1000
  • 0 <= value <= 1000
  • insertFront, insertLast, deleteFront, deleteLast, getFront, getRear, isEmpty, isFull  调用次数不大于 2000 次

解法1：数组

类似题型：LeetCode 622. 设计循环队列-CSDN博客

我们利用循环队列实现双端队列。

在循环队列中的基础上，我们增加 insertFront 和 deleteFront 函数实现即可。根据循环队列的定义，队列判空的条件是 front=rear，而队列判满的条件是 front=(rear+1) mod capacity。

对于一个固定大小的数组，只要知道队尾 rear 与队首 front，即可计算出队列当前的长度：

(rear−front+capacity) mod capacity
循环双端队列与循环队列的属性一致:

  • elements：一个固定大小的数组，用于保存循环队列的元素。
  • capacity：循环队列的容量，即队列中最多可以容纳的元素数量。
  • front：队列首元素对应的数组的索引。
  • rear：队列尾元素对应的索引的下一个索引。

循环双端队列的接口方法如下：

  • MyCircularDeque(int k)：初始化队列，同时 base 数组的空间初始化大小为 k+1。front,rear 全部初始化为 0。
  • insertFront(int value)：队列未满时，在队首插入一个元素。我们首先将队首 front 移动一个位置，更新队首索引为 front 更新为 (front−1+capacity)modcapacity。
  • insertLast(int value)：队列未满时，在队列的尾部插入一个元素，并同时将队尾的索引 rear 更新为 (rear+1)modcapacity。
  • deleteFront()：队列不为空时，从队首删除一个元素，并同时将队首的索引 front 更新为 (front+1)modcapacity。
  • deleteLast()：队列不为空时，从队尾删除一个元素。并同时将队尾的索引 rear 更新为 (rear−1+capacity)modcapacity。
  • getFront()：返回队首的元素，需要检测队列是否为空。
  • getRear()：返回队尾的元素，需要检测队列是否为空。
  • isEmpty()：检测队列是否为空，根据之前的定义只需判断 rear 是否等于 front。
  • isFull()：检测队列是否已满，根据之前的定义只需判断 front 是否等于 (rear+1)modcapacity。

Java版：

class MyCircularDeque {
    int capacity;
    int front;
    int rear;
    int[] elements;

    public MyCircularDeque(int k) {
        capacity = k + 1;
        front = 0;
        rear = 0;
        elements = new int[k + 1];
    }
    
    public boolean insertFront(int value) {
        if (isFull()) {
            return false;
        }
        front = (front - 1 + capacity) % capacity;
        elements[front] = value;
        return true;
    }
    
    public boolean insertLast(int value) {
        if (isFull()) {
            return false;
        }
        elements[rear] = value;
        rear = (rear + 1) % capacity;
        return true;
    }
    
    public boolean deleteFront() {
        if (isEmpty()) {
            return false;
        }
        front = (front + 1) % capacity;
        return true;
    }
    
    public boolean deleteLast() {
        if (isEmpty()) {
            return false;
        }
        rear = (rear - 1 + capacity) % capacity;
        return true;
    }
    
    public int getFront() {
        if (isEmpty()) {
            return -1;
        }
        return elements[front];
    }
    
    public int getRear() {
        if (isEmpty()) {
            return -1;
        }
        return elements[(rear - 1 + capacity) % capacity];
    }
    
    public boolean isEmpty() {
        return front == rear;
    }
    
    public boolean isFull() {
        return (rear + 1) % capacity == front;
    }
}

/**
 * Your MyCircularDeque object will be instantiated and called as such:
 * MyCircularDeque obj = new MyCircularDeque(k);
 * boolean param_1 = obj.insertFront(value);
 * boolean param_2 = obj.insertLast(value);
 * boolean param_3 = obj.deleteFront();
 * boolean param_4 = obj.deleteLast();
 * int param_5 = obj.getFront();
 * int param_6 = obj.getRear();
 * boolean param_7 = obj.isEmpty();
 * boolean param_8 = obj.isFull();
 */

Python3版：

class MyCircularDeque:

    def __init__(self, k: int):
        self.capacity = k + 1
        self.front = 0
        self.rear = 0
        self.elements = [0] * (k + 1)

    def insertFront(self, value: int) -> bool:
        if self.isFull():
            return False
        self.front = (self.front - 1) % self.capacity
        self.elements[self.front] = value
        return True

    def insertLast(self, value: int) -> bool:
        if self.isFull():
            return False
        self.elements[self.rear] = value
        self.rear = (self.rear + 1) % self.capacity
        return True

    def deleteFront(self) -> bool:
        if self.isEmpty():
            return False
        self.front = (self.front + 1) % self.capacity
        return True

    def deleteLast(self) -> bool:
        if self.isEmpty():
            return False
        self.rear = (self.rear - 1) % self.capacity
        return True

    def getFront(self) -> int:
        if self.isEmpty():
            return -1
        return self.elements[self.front]

    def getRear(self) -> int:
        if self.isEmpty():
            return -1
        return self.elements[self.rear - 1]

    def isEmpty(self) -> bool:
        return self.front == self.rear

    def isFull(self) -> bool:
        return (self.rear + 1) % self.capacity == self.front 


# Your MyCircularDeque object will be instantiated and called as such:
# obj = MyCircularDeque(k)
# param_1 = obj.insertFront(value)
# param_2 = obj.insertLast(value)
# param_3 = obj.deleteFront()
# param_4 = obj.deleteLast()
# param_5 = obj.getFront()
# param_6 = obj.getRear()
# param_7 = obj.isEmpty()
# param_8 = obj.isFull()

复杂度分析

  • 时间复杂度：初始化和每项操作的时间复杂度均为 O(1)。

  • 空间复杂度：O(k)，其中 k 为给定的队列元素数目。

解法2：链表

我们同样可以使用双向链表来模拟双端队列，实现双端队列队首与队尾元素的添加、删除。双向链表实现比较简单，双向链表支持 O(1) 时间复杂度内在指定节点的前后插入新的节点或者删除新的节点。

循环双端队列的属性如下:

  • head：队列的头节点；
  • tail：队列的尾节点
  • capacity：队列的容量大小。
  • size：队列当前的元素数量。

循环双端队列的接口方法如下：

  • MyCircularDeque(int k)：初始化队列，同时初始化队列元素数量 size 为 0。head,tail 初始化为空。
  • insertFront(int value)：队列未满时，在队首头结点 head 之前插入一个新的节点，并更新 head，并更新 size。
  • insertLast(int value)：队列未满时，在队w尾节点 tail 之后插入一个新的节点，并更新 tail，并更新 size。
  • deleteFront()：队列不为空时，删除头结点 head，并更新 head 为 head 的后一个节点，并更新 size。
  • deleteLast()：队列不为空时，删除尾结点 tail，并更新 tail 为 tail 的前一个节点，并更新 size。
  • getFront()：返回队首节点指向的值，需要检测队列是否为空。
  • getRear()：返回队尾节点指向的值，需要检测队列是否为空。
  • isEmpty()：检测当前 size 是否为 0。
  • isFull()：检测当前 size 是否为 capacity。

Java版：

class DLinkListNode {
    int val;
    DLinkListNode prev, next;

    public DLinkListNode(int val) {
        this.val = val;
    }
}

class MyCircularDeque {
    int capacity;
    int size;
    DLinkListNode head, tail;

    public MyCircularDeque(int k) {
        capacity = k;
        size = 0;
    }
    
    public boolean insertFront(int value) {
        if (size == capacity) {
            return false;
        }
        DLinkListNode node = new DLinkListNode(value);
        if (size == 0) {
            head = node;
            tail = node;
        } else {
            node.next = head;
            head.prev = node;
            head = node;
        }
        size++;
        return true;
    }
    
    public boolean insertLast(int value) {
        if (size == capacity) {
            return false;
        }
        DLinkListNode node = new DLinkListNode(value);
        if (size == 0) {
            head = node;
            tail = node;
        } else {
            tail.next = node;
            node.prev = tail;
            tail = node;
        }
        size++;
        return true;
    }
    
    public boolean deleteFront() {
        if (size == 0) {
            return false;
        }
        head = head.next;
        if (head != null) {
            head.prev = null;
        }
        size--;
        return true;
    }
    
    public boolean deleteLast() {
        if (size == 0) {
            return false;
        }
        tail = tail.prev;
        if (tail != null) {
            tail.next = null;
        }
        size--;
        return true;
    }
    
    public int getFront() {
        return size == 0 ? -1 : head.val;
    }
    
    public int getRear() {
        return size == 0 ? -1 : tail.val;
    }
    
    public boolean isEmpty() {
        return size == 0;
    }
    
    public boolean isFull() {
        return size == capacity;
    }
}

/**
 * Your MyCircularDeque object will be instantiated and called as such:
 * MyCircularDeque obj = new MyCircularDeque(k);
 * boolean param_1 = obj.insertFront(value);
 * boolean param_2 = obj.insertLast(value);
 * boolean param_3 = obj.deleteFront();
 * boolean param_4 = obj.deleteLast();
 * int param_5 = obj.getFront();
 * int param_6 = obj.getRear();
 * boolean param_7 = obj.isEmpty();
 * boolean param_8 = obj.isFull();
 */

Python3版：

class Node:

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

class MyCircularDeque:

    def __init__(self, k: int):
        self.capacity = k
        self.size = 0
        self.head = self.tail = None

    def insertFront(self, value: int) -> bool:
        if self.isFull():
            return False
        node = Node(value)
        if self.size == 0:
            self.head = self.tail = node 
        else:
            node.next = self.head
            self.head.prev = node 
            self.head = node 
        self.size += 1
        return True

    def insertLast(self, value: int) -> bool:
        if self.isFull():
            return False
        node = Node(value)
        if self.size == 0:
            self.head = self.tail = node 
        else:
            self.tail.next = node 
            node.prev = self.tail
            self.tail = node 
        self.size += 1
        return True

    def deleteFront(self) -> bool:
        if self.isEmpty():
            return False
        self.head = self.head.next
        if self.head:
            self.head.prev = None
        self.size -= 1
        return True

    def deleteLast(self) -> bool:
        if self.isEmpty():
            return False
        self.tail = self.tail.prev 
        if self.tail:
            self.tail.next = None
        self.size -= 1
        return True

    def getFront(self) -> int:
        return -1 if self.isEmpty() else self.head.val

    def getRear(self) -> int:
        return -1 if self.isEmpty() else self.tail.val

    def isEmpty(self) -> bool:
        return self.size == 0

    def isFull(self) -> bool:
        return self.size == self.capacity


# Your MyCircularDeque object will be instantiated and called as such:
# obj = MyCircularDeque(k)
# param_1 = obj.insertFront(value)
# param_2 = obj.insertLast(value)
# param_3 = obj.deleteFront()
# param_4 = obj.deleteLast()
# param_5 = obj.getFront()
# param_6 = obj.getRear()
# param_7 = obj.isEmpty()
# param_8 = obj.isFull()

复杂度分析

  • 时间复杂度：初始化和每项操作的时间复杂度均为 O(1)。

  • 空间复杂度：O(k)，其中 k 为给定的队列元素数目。

算法白菜
关注
  • 27
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java-leetcode题解之第641题设计循环双端队列.zip
06-12
本资源“java-leetcode题解之第641题设计循环双端队列.zip”是一个关于Java实现LeetCode第641题的解题代码包，主要涉及的数据结构是循环双端队列（Circular Doubly Linked List）。现在，我们将深入探讨这个题目及其...
设计循环双端队列
12-21
设计循环双端队列 题目 设计实现双端队列。 请不要使用内置的双端队列库。 链接：https://leetcode-cn.com/problems/design-circular-deque/ 思路 题目要求不使用内置的双端队列库，那么可以考虑使用双指针，即队首...
LeetCode[641]设计循环双端队列
月亮被咬碎成星星的博客
10-07 277
LeetCode[641]设计循环双端队列 java解法
Leetcode 641. 设计循环双端队列
clownote
03-26 136
Leetcode 641. 设计循环双端队列 题目 设计实现双端队列。 你的实现需要支持以下操作： MyCircularDeque(k)：构造函数,双端队列的大小为k。 insertFront()：将一个元素添加到双端队列头部。 如果操作成功返回 true。 insertLast()：将一个元素添加到双端队列尾部。如果操作成功返回 true。 deleteFront()：从双端队列头部删除一个元...
leetcode641. 设计循环双端队列
weixin_44392348的博客
10-18 45
【代码】leetcode641. 设计循环双端队列。
LeetCode 641.设计循环双端队列
soulmate______的博客
03-29 158
题目描述 设计实现双端队列。 你的实现需要支持以下操作： MyCircularDeque(k)：构造函数,双端队列的大小为k。 insertFront()：将一个元素添加到双端队列头部。 如果操作成功返回 true。 insertLast()：将一个元素添加到双端队列尾部。如果操作成功返回 true。 deleteFront()：从双端队列头部删除一个元素。 如果操作成功返回 true。 del...
Leetcode 641. 设计循环双端队列 C++
weixin_43750513的博客
07-23 158
Leetcode 641. 设计循环双端队列 题目 设计实现双端队列。 你的实现需要支持以下操作： MyCircularDeque(k)：构造函数,双端队列的大小为k。 insertFront()：将一个元素添加到双端队列头部。如果操作成功返回 true。 insertLast()：将一个元素添加到双端队列尾部。如果操作成功返回 true。 deleteFront()：从双端队列头部删除一个元素。 如果操作成功返回 true。 deleteLast()：从双端队列尾部删除一个元素。如果操作成功返回 tru
641. 设计循环双端队列
zrh_CSDN的博客
02-28 213
设计实现双端队列。 你的实现需要支持以下操作： MyCircularDeque(k)：构造函数,双端队列的大小为k。 insertFront()：将一个元素添加到双端队列头部。 如果操作成功返回 true。 insertLast()：将一个元素添加到双端队列尾部。如果操作成功返回 true。 deleteFront()：从双端队列头部删除一个元素。 如果操作成功返回 true。 dele...
Leetcode 641.设计循环双端队列
Pang_ling的博客
03-30 140
题目描述 示例 添加链接描述
641.设计循环双端队列
m0_68014532的博客
09-14 93
设计实现双端队列。
leetcode：641. 设计循环双端队列
UUUUTaossienUUUU的专栏
12-18 457
设计循环双端队列
程序员面试金典 – 面试题 04.09. 二叉搜索树序列（双端队列+回溯）**
12-21
这个问题涉及到二叉搜索树的性质、双端队列（deque）的使用以及回溯算法的应用。 首先，二叉搜索树是一种特殊的二叉树，其每个节点的值大于左子树中任何节点的值，小于右子树中任何节点的值。这确保了树的有序性，...
leetcode题目汇总.docx
03-06
这可以使用层次遍历（BFS）配合双端队列（deque）来实现，队列的末尾存储当前层的节点，每层结束后弹出队首元素，即为该层的最右侧节点。 以上是LeetCode题目中涉及的一些核心知识点，涵盖网络编程、数据结构（链表...
leetcode亲密字符串-leetcode-js:js算法学习笔记(leetcode刷题)
07-06
641.设计循环双端队列 1670.设计前中后队列 933.最近的请求次数 智力发散题 面试题17.09.第K个数 859.亲密字符串 860.柠檬水找零 969.煎饼排序 621.任务调度器 递归与栈：解决表达式求值 面试题03.04.化栈为队 682....
C语言 | Leetcode C语言题解之第337题打家劫舍III
m0_59237910的博客
08-15 377
C语言 | Leetcode C语言题解之第337题打家劫舍III
Java | Leetcode Java题解之第337题打家劫舍III
m0_57195758的博客
08-15 343
Java | Leetcode Java题解之第337题打家劫舍III
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 380
C++ | Leetcode C++题解之第337题打家劫舍III
日拱一卒（4）——leetcode学习记录：路径总和
最新发布
m0_72708335的博客
08-17 204
左右节点都存在，返回 递归(左子节点,targetSum-root.val)or递归(右子节点,targetSum-root.val)其他，返回 递归(左子节点or右子节点,targetSum-root.val)左右子节点都不存在，返回targetSum == root.val。的路径，这条路径上所有节点值相加等于目标和。和一个表示目标和的整数。节点不存在，返回False。是指没有子节点的节点。
leetcode 204.计数质数 python
09-06
你可以使用埃拉托斯特尼筛法（Sieve of Eratosthenes）来解决LeetCode 204题，计数质数问题。下面是使用Python的实现示例代码： ```python class Solution: def countPrimes(self, n: int) -> int: if n < 2: return 0 # 初始化标记数组，默认所有数都是质数 is_prime = [1] * n is_prime[0] = is_prime[1] = 0 # 埃氏筛法 for i in range(2, int(n ** 0.5) + 1): if is_prime[i]: # 将i的倍数标记为合数 is_prime[i*i:n:i] = [0] * len(is_prime[i*i:n:i]) # 统计质数的个数 return sum(is_prime) ``` 这段代码中，我们首先初始化一个长度为n的标记数组is_prime，用于表示每个数字是否为质数（1表示质数，0表示合数）。然后从2开始遍历到根号n，对于每个质数i，将其所有的倍数标记为合数。最后，统计标记数组中值为1的个数，即为质数的个数。 你可以将以上代码复制到LeetCode上进行测试。希望能对你有所帮助！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值