[LeetCode] 641. Design Circular Deque

题：https://leetcode.com/problems/design-circular-deque/

题目

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.

题目大意

实现一个有容量限制的 双向队列

思路

1. 链表直接实现

设置 两个 双向链表 结点 head , tail 。指向 队列的收尾， 用size记录 队列的长度。
初始化时候，head 与 tail 相互指向。

初始化时，将 head 与tail 的结点val 设置为 -1。
当size 为0时，直接返回 为-1。不用考虑特例。

class DequeueNode{
    DequeueNode pre;
    DequeueNode next;
    int val;
    public DequeueNode(int v){
        val = v;
    }

}


class MyCircularDeque {

    /** Initialize your data structure here. Set the size of the deque to be k. */
    DequeueNode head;
    DequeueNode tail;
    int size;
    int cap;

    public MyCircularDeque(int k) {
        cap = k;
        size = 0;
        head = new DequeueNode(-1);
        tail = new DequeueNode(-1);
        head.next = tail;
        tail.pre = head;
    }

    /** Adds an item at the front of Deque. Return true if the operation is successful. */
    public boolean insertFront(int value) {
        if(this.isFull())
            return false;
        DequeueNode curNode = new DequeueNode(value);
        head.next.pre = curNode ;
        curNode.next = head.next;
        head.next = curNode;
        curNode.pre = head;
        size++;
        return true;
    }

    /** Adds an item at the rear of Deque. Return true if the operation is successful. */
    public boolean insertLast(int value) {
        if(this.isFull())
            return false;
        DequeueNode curNode = new DequeueNode(value);
         tail.pre.next =curNode;
        curNode.pre = tail.pre;
        curNode.next = tail;
        tail.pre = curNode;
        size++;
        return true;
    }

    /** Deletes an item from the front of Deque. Return true if the operation is successful. */
    public boolean deleteFront() {
        if(this.isEmpty())
            return false;
        head.next.next.pre = head;
        head.next = head.next.next;
        size --;
        return true;
    }

    /** Deletes an item from the rear of Deque. Return true if the operation is successful. */
    public boolean deleteLast() {
        if(this.isEmpty())
            return false;
        tail.pre.pre.next = tail;
        tail.pre = tail.pre.pre;
        size --;
        return true;

    }

    /** Get the front item from the deque. */
    public int getFront() {
        return head.next.val;
    }

    /** Get the last item from the deque. */
    public int getRear() {
        return tail.pre.val;

    }

    /** Checks whether the circular deque is empty or not. */
    public boolean isEmpty() {
        return size ==0;
    }

    /** Checks whether the circular deque is full or not. */
    public boolean isFull() {
        return size == cap;
    }
}

/**
 * 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();
 */

数组 模拟

这里 使用front , rear 指向不同的 位置。但这两指针的 增长反向不同，应该是反方向。

如这里 front = k-1 ，rear = 0。
当insertFront 时，(front - 1 + size) % size；
当insertRear 时，(rear + 1 + size) % size;
需要加 模 运算。

class MyCircularDeque {
    int[] arr;
    int size;
    int cap;
    int front;
    int rear;
    
    /** Initialize your data structure here. Set the size of the deque to be k. */
    public MyCircularDeque(int k) {
        arr = new int[k];
        size = 0;
        cap  =k;
        front = k - 1;
        rear = 0;
    }
    
    /** Adds an item at the front of Deque. Return true if the operation is successful. */
    public boolean insertFront(int value) {
        if(size == cap)
            return false;
        arr[front] = value;
        front = (front - 1 + cap)%cap;
        size++;
        return true;
    }
    
    /** Adds an item at the rear of Deque. Return true if the operation is successful. */
    public boolean insertLast(int value) {
        if(size == cap )
            return false;
        arr[rear] = value;
        rear = (rear + 1  + cap)%cap;
        size++;
        return true;
    }
    
    /** Deletes an item from the front of Deque. Return true if the operation is successful. */
    public boolean deleteFront() {
        if(size == 0)
            return false;
        front = (front + 1  + cap)% cap;
        size--;
        return true;
    }
    
    /** Deletes an item from the rear of Deque. Return true if the operation is successful. */
    public boolean deleteLast() {
        if(size == 0)
            return false;
        rear = (rear -1 +cap ) % cap;
        size--;
        return true;
    }
    
    /** Get the front item from the deque. */
    public int getFront() {
        if(size == 0)
            return -1;
        return arr[(front+1 + cap)%cap];
    }
    
    /** Get the last item from the deque. */
    public int getRear() {
        if(size == 0)
            return -1;
        return arr[(rear - 1 + cap) %cap];
        
    }
    
    /** Checks whether the circular deque is empty or not. */
    public boolean isEmpty() {
        return size == 0;
    }
    
    /** Checks whether the circular deque is full or not. */
    public boolean isFull() {
        return size == cap;
    }
}

/**
 * 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();
 */