LeetCode实战：设计循环双端队列

题目英文

Design your implementation of the circular double-ended queue (deque).

Your implementation should support following operations:

• MyCircularDeque(k): Constructor, set the size of the deque to be k.
• insertFront(): Adds an item at the front of Deque. Return true if the operation is successful.
• insertLast(): Adds an item at the rear of Deque. Return true if the operation is successful.
• deleteFront(): Deletes an item from the front of Deque. Return true if the operation is successful.
• deleteLast(): Deletes an item from the rear of Deque. Return true if the operation is successful.
• getFront(): Gets the front item from the Deque. If the deque is empty, return -1.
• getRear(): Gets the last item from Deque. If the deque is empty, return -1.
• isEmpty(): Checks whether Deque is empty or not.
• isFull(): Checks whether Deque is full or not.

Example:

MyCircularDeque circularDeque = new MycircularDeque(3); // set the size to be 3
circularDeque.insertLast(1);			// return true
circularDeque.insertLast(2);			// return true
circularDeque.insertFront(3);			// return true
circularDeque.insertFront(4);			// return false, the queue is full
circularDeque.getRear();  			// return 2
circularDeque.isFull();				// return true
circularDeque.deleteLast();			// return true
circularDeque.insertFront(4);			// return true
circularDeque.getFront();			// return 4

Note:

• All values will be in the range of [0, 1000].
• The number of operations will be in the range of [1, 1000].
• Please do not use the built-in Deque library.

---

题目中文

设计实现双端队列。

你的实现需要支持以下操作：

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

示例：

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, 1000]
• 操作次数的范围为 [1, 1000]
• 请不要使用内置的双端队列库。

---

算法实现

public class MyCircularDeque {

    private int _pFront;
    private int _pRear;
    private readonly int[] _dataset;
    private int _length;
    private int _maxSize;
    
    /** Initialize your data structure here. Set the size of the deque to be k. */
    public MyCircularDeque(int k) {
        _dataset = new int[k];
        _length = 0;
        _maxSize = k;
        _pFront = 0;
        _pRear = 0;        
    }
    
    /** Adds an item at the front of Deque. Return true if the operation is successful. */
    public bool InsertFront(int value) {
        if (_length == _maxSize)
            return false;

        _pFront = (_pFront - 1 + _maxSize)%_maxSize;
        _dataset[_pFront] = value;
        _length++;
        return true;        
    }
    
    /** Adds an item at the rear of Deque. Return true if the operation is successful. */
    public bool InsertLast(int value) {
        if (_length == _maxSize)
            return false;

        _dataset[_pRear] = value;
        _pRear = (_pRear + 1)%_maxSize;
        _length++;
        return true;        
    }
    
    /** Deletes an item from the front of Deque. Return true if the operation is successful. */
    public bool DeleteFront() {
        if (_length == 0)
            return false;
        _pFront = (_pFront + 1)%_maxSize;
        _length--;
        return true;        
    }
    
    /** Deletes an item from the rear of Deque. Return true if the operation is successful. */
    public bool DeleteLast() {
        if (_length == 0)
            return false;
        _pRear = (_pRear - 1 + _maxSize)%_maxSize;
        _length--;
        return true;        
    }
    
    /** Get the front item from the deque. */
    public int GetFront() {
        if (_length == 0)
            return -1;

        return _dataset[_pFront];        
    }
    
    /** Get the last item from the deque. */
    public int GetRear() {
        if (_length == 0)
            return -1;
        int index = (_pRear - 1 + _maxSize)%_maxSize;
        return _dataset[index];        
    }
    
    /** Checks whether the circular deque is empty or not. */
    public bool IsEmpty() {
        return _length == 0;        
    }
    
    /** Checks whether the circular deque is full or not. */
    public bool IsFull() {
        return _length == _maxSize;        
    }
}

/**
 * Your MyCircularDeque object will be instantiated and called as such:
 * MyCircularDeque obj = new MyCircularDeque(k);
 * bool param_1 = obj.InsertFront(value);
 * bool param_2 = obj.InsertLast(value);
 * bool param_3 = obj.DeleteFront();
 * bool param_4 = obj.DeleteLast();
 * int param_5 = obj.GetFront();
 * int param_6 = obj.GetRear();
 * bool param_7 = obj.IsEmpty();
 * bool param_8 = obj.IsFull();
 */

---

实验结果

• 状态：通过
• 51 / 51 个通过测试用例
• 执行用时：216 ms

---

相关图文：

• LeetCode实战：两数之和
• LeetCode实战：三数之和
• LeetCode实战：缺失的第一个正数
• LeetCode实战：求众数
• LeetCode实战：快乐数
• LeetCode实战：删除链表的倒数第N个节点
• LeetCode实战：合并两个有序链表
• LeetCode实战：合并K个排序链表
• LeetCode实战：两两交换链表中的节点
• LeetCode实战：旋转链表
• LeetCode实战：环形链表
• LeetCode实战：有效的括号
• LeetCode实战：最长有效括号
• LeetCode实战：逆波兰表达式求值
• LeetCode实战：相同的树
• LeetCode实战：对称二叉树
• LeetCode实战：二叉树的最大深度
• LeetCode实战：将有序数组转换为二叉搜索树
• LeetCode实战：搜索二维矩阵