[Swift]LeetCode622. 设计循环队列 | Design Circular Queue

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10472658.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Design your implementation of the circular queue. The circular queue is a linear data structure in which the operations are performed based on FIFO (First In First Out) principle and the last position is connected back to the first position to make a circle. It is also called "Ring Buffer".

One of the benefits of the circular queue is that we can make use of the spaces in front of the queue. In a normal queue, once the queue becomes full, we cannot insert the next element even if there is a space in front of the queue. But using the circular queue, we can use the space to store new values.

Your implementation should support following operations:

• MyCircularQueue(k): Constructor, set the size of the queue to be k.
• Front: Get the front item from the queue. If the queue is empty, return -1.
• Rear: Get the last item from the queue. If the queue is empty, return -1.
• enQueue(value): Insert an element into the circular queue. Return true if the operation is successful.
• deQueue(): Delete an element from the circular queue. Return true if the operation is successful.
• isEmpty(): Checks whether the circular queue is empty or not.
• isFull(): Checks whether the circular queue is full or not. 

Example:

MyCircularQueue circularQueue = new MyCircularQueue(3); // set the size to be 3
circularQueue.enQueue(1);  // return true
circularQueue.enQueue(2);  // return true
circularQueue.enQueue(3);  // return true
circularQueue.enQueue(4);  // return false, the queue is full
circularQueue.Rear();  // return 3
circularQueue.isFull();  // return true
circularQueue.deQueue();  // return true
circularQueue.enQueue(4);  // return true
circularQueue.Rear();  // 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 Queue library.

---

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

• MyCircularQueue(k): 构造器，设置队列长度为 k 。
• Front: 从队首获取元素。如果队列为空，返回 -1 。
• Rear: 获取队尾元素。如果队列为空，返回 -1 。
• enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
• deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
• isEmpty(): 检查循环队列是否为空。
• isFull(): 检查循环队列是否已满。 

示例：

MyCircularQueue circularQueue = new MycircularQueue(3); // 设置长度为 3

circularQueue.enQueue(1);  // 返回 true

circularQueue.enQueue(2);  // 返回 true

circularQueue.enQueue(3);  // 返回 true

circularQueue.enQueue(4);  // 返回 false，队列已满

circularQueue.Rear();  // 返回 3

circularQueue.isFull();  // 返回 true

circularQueue.deQueue();  // 返回 true

circularQueue.enQueue(4);  // 返回 true

circularQueue.Rear();  // 返回 4

提示：

• 所有的值都在 0 至 1000 的范围内；
• 操作数将在 1 至 1000 的范围内；
• 请不要使用内置的队列库。

---

Runtime: 124 ms

Memory Usage: 20.2 MB

class MyCircularQueue {

    var array: [Int] = []
    
    var curLength = 0
    var length = 0
    
    var startIndex = 0
    var endIndex = -1
    
    /** Initialize your data structure here. Set the size of the queue to be k. */
    init(_ k: Int) {
        length = k
        
        for _ in 0..<k {
            array.append(0)
        }
    }
    /** Insert an element into the circular queue. Return true if the operation is successful. */

    func enQueue(_ value: Int) -> Bool {
        
        if curLength == length {
            return false
        } else {
            endIndex = (endIndex + 1) % length
            array[endIndex] = value
            
            curLength += 1
            
            return true
        }
    }
    /** Delete an element from the circular queue. Return true if the operation is successful. */

    func deQueue() -> Bool {
    
        if curLength == 0 {
            return false
        } else {
            startIndex = (startIndex + 1) % length
            curLength -= 1
            
            return true
        }
    }
    /** Get the front item from the queue. */

    func Front() -> Int {
        
        if curLength == 0 {
            return -1
        } else {
            return array[startIndex]
        }
    }
    /** Get the last item from the queue. */

    func Rear() -> Int {
        
        if curLength == 0 {
            return -1
        } else {
            return array[endIndex]
        }
    }
    /** Checks whether the circular queue is empty or not. */

    func isEmpty() -> Bool {
        if curLength == 0 {
            return true
        } else {
            return false
        }
    }
    /** Checks whether the circular queue is full or not. */

    func isFull() -> Bool {
        if curLength == length {
            return true
        } else {
            return false
        }
    }
}

/**
 * Your MyCircularQueue object will be instantiated and called as such:
 * let obj = MyCircularQueue(k)
 * let ret_1: Bool = obj.enQueue(value)
 * let ret_2: Bool = obj.deQueue()
 * let ret_3: Int = obj.Front()
 * let ret_4: Int = obj.Rear()
 * let ret_5: Bool = obj.isEmpty()
 * let ret_6: Bool = obj.isFull()
 */

---

144ms

class MyCircularQueue {
    
    private var queue: [Int]
    private var size: Int
    private let cap: Int
    private var front: Int
    private var rear: Int

    /** Initialize your data structure here. Set the size of the queue to be k. */
    init(_ k: Int) {
        queue = Array(repeating: 0, count: k)
        size = 0
        cap = k
        front = 0
        rear = -1
    }
    /** Insert an element into the circular queue. Return true if the operation is successful. */

    func enQueue(_ value: Int) -> Bool {
        guard !isFull() else { return false }
        rear = (rear + 1) % cap
        queue[rear] = value
        size += 1
        return true
    }
    /** Delete an element from the circular queue. Return true if the operation is successful. */

    func deQueue() -> Bool {
        guard !isEmpty() else { return false }
        front = (front + 1) % cap
        size -= 1
        return true
        
    }
    /** Get the front item from the queue. */

    func Front() -> Int {
        guard !isEmpty() else { return -1 }
        return queue[front]
    }
    /** Get the last item from the queue. */

    func Rear() -> Int {
        guard !isEmpty() else { return -1 }
        return queue[rear]
    }
    /** Checks whether the circular queue is empty or not. */

    func isEmpty() -> Bool {
        return size == 0
    }
    /** Checks whether the circular queue is full or not. */

    func isFull() -> Bool {
        return size == cap
    }
}

/**
 * Your MyCircularQueue object will be instantiated and called as such:
 * let obj = MyCircularQueue(k)
 * let ret_1: Bool = obj.enQueue(value)
 * let ret_2: Bool = obj.deQueue()
 * let ret_3: Int = obj.Front()
 * let ret_4: Int = obj.Rear()
 * let ret_5: Bool = obj.isEmpty()
 * let ret_6: Bool = obj.isFull()
 */

---

148ms

class MyCircularQueue {
    private var size: Int = 0
    private var head: Int = -1
    private var tail: Int = -1
    private var data = [Int]()

    /** Initialize your data structure here. Set the size of the queue to be k. */
    init(_ k: Int) {
        size = k;
        data = Array(repeating: 0, count: size)
    }

    /** Insert an element into the circular queue. Return true if the operation is successful. */
    func enQueue(_ value: Int) -> Bool {
        var tempHead = head+1
        if tempHead == size {
            tempHead = 0
        }
        if tempHead == tail {
            return false
        }
        
        head = tempHead
        if tail == -1 {
            tail = tempHead
        }
        data[head] = value
        return true
    }
    /** Delete an element from the circular queue. Return true if the operation is successful. */

    func deQueue() -> Bool {
        if tail == -1 {
            return false
        }
        
        if head == tail {
            head = -1
            tail = -1
            return true
        }
        
        tail = tail + 1
        if tail == size {
            tail = 0
        }
        return true
    }
    /** Get the front item from the queue. */

    func Front() -> Int {
        if tail == -1 {
            return -1
        }
        return data[tail]
        
    }
    /** Get the last item from the queue. */

    func Rear() -> Int {
        if head == -1 {
            return -1
        }
        return data[head]
        
    }
    /** Checks whether the circular queue is empty or not. */

    func isEmpty() -> Bool {
        if head == -1 {
            return true
        }
        return false
        
    }
    /** Checks whether the circular queue is full or not. */

    func isFull() -> Bool {
        if (head+1 == tail) {
            return true
        }
        else {
            if ( (head+1-size) == tail) {
                return true
            }
            return false
        }
    }
}

/**
 * Your MyCircularQueue object will be instantiated and called as such:
 * let obj = MyCircularQueue(k)
 * let ret_1: Bool = obj.enQueue(value)
 * let ret_2: Bool = obj.deQueue()
 * let ret_3: Int = obj.Front()
 * let ret_4: Int = obj.Rear()
 * let ret_5: Bool = obj.isEmpty()
 * let ret_6: Bool = obj.isFull()
 */

---

152ms

class MyCircularQueue {
    private var circularArray: [Int]
    private var readIndex = 0
    private var writeIndex = 0
    /** Initialize your data structure here. Set the size of the queue to be k. */
    init(_ k: Int) {
        circularArray = Array(repeating: 0, count: k)
    }
    /** Insert an element into the circular queue. Return true if the operation is successful. */

    func enQueue(_ value: Int) -> Bool {
        guard !isFull() else {
            return false
        }
        circularArray[writeIndex % circularArray.count] = value
        writeIndex += 1
        return true
    }
    /** Delete an element from the circular queue. Return true if the operation is successful. */

    func deQueue() -> Bool {
        guard !isEmpty() else {
            return false
        }
        readIndex += 1 
        return true
    }
    /** Get the front item from the queue. */

    func Front() -> Int {
        guard !isEmpty() else {
            return -1
        }
        return circularArray[readIndex % circularArray.count]
    }
    /** Get the last item from the queue. */

    func Rear() -> Int {
        guard !isEmpty() else {
            return -1
        }
        return circularArray[ (writeIndex - 1) % circularArray.count ]
    }
    /** Checks whether the circular queue is empty or not. */

    func isEmpty() -> Bool {
        return writeIndex == readIndex
    }
    /** Checks whether the circular queue is full or not. */

    func isFull() -> Bool {
        return writeIndex - readIndex == circularArray.count
    }
}

/**
 * Your MyCircularQueue object will be instantiated and called as such:
 * let obj = MyCircularQueue(k)
 * let ret_1: Bool = obj.enQueue(value)
 * let ret_2: Bool = obj.deQueue()
 * let ret_3: Int = obj.Front()
 * let ret_4: Int = obj.Rear()
 * let ret_5: Bool = obj.isEmpty()
 * let ret_6: Bool = obj.isFull()
 */

---

164ms

class MyCircularQueue {
    
    private var queueSize: Int = 0
    private var queue = [Int: Int]()
    
    private var frontIndex: Int = 0
    private var endIndex: Int = 0
    
    /** Initialize your data structure here. Set the size of the queue to be k. */
    init(_ k: Int) {
        queueSize = k
    }
    /** Insert an element into the circular queue. Return true if the operation is successful. */
    
    func enQueue(_ value: Int) -> Bool {
        if !isFull() {
            if queue[endIndex] != nil {
                endIndex = updateIndex(from: endIndex)
            }
            queue[endIndex] = value
            return true
        } else {
            return false
        }
    }
    /** Delete an element from the circular queue. Return true if the operation is successful. */
    
    func deQueue() -> Bool {
        
        if !isEmpty() {
            queue.removeValue(forKey: frontIndex)
            frontIndex = updateIndex(from: frontIndex)
            endIndex = isEmpty() ? frontIndex : endIndex
            return true
        } else {
            return false
        }
    }
    /** Get the front item from the queue. */
    
    func Front() -> Int {
        return isEmpty() ? -1 : queue[frontIndex] ?? -1
    }
    /** Get the last item from the queue. */
    
    func Rear() -> Int {
        return isEmpty() ? -1 : queue[endIndex] ?? -1
    }
    /** Checks whether the circular queue is empty or not. */
    
    func isEmpty() -> Bool {
        return queue.count == 0
    }
    /** Checks whether the circular queue is full or not. */
    
    func isFull() -> Bool {
        return queue.count >= queueSize
    }
    
    private func updateIndex(from index: Int) -> Int {
        return index < queueSize - 1 ? index + 1 : 0
    }
}

/**
 * Your MyCircularQueue object will be instantiated and called as such:
 * let obj = MyCircularQueue(k)
 * let ret_1: Bool = obj.enQueue(value)
 * let ret_2: Bool = obj.deQueue()
 * let ret_3: Int = obj.Front()
 * let ret_4: Int = obj.Rear()
 * let ret_5: Bool = obj.isEmpty()
 * let ret_6: Bool = obj.isFull()
 */

---

192ms

class MyCircularQueue {

    private var data: [Int]
    private var p_start: Int
    private var p_tail: Int
    private var count: Int
    private var len: Int
    
    /** Initialize your data structure here. Set the size of the queue to be k. */
    init(_ k: Int) {
        data = [Int].init(repeating: 0, count: k)
        p_start = 0
        p_tail = 0
        len = k
        count = 0
    }
    /** Insert an element into the circular queue. Return true if the operation is successful. */

    func enQueue(_ value: Int) -> Bool {
        if isFull() { return false }
        
        data[p_tail] = value
        count += 1
        p_tail = (p_tail + 1) % len
        return true
        
    }
    /** Delete an element from the circular queue. Return true if the operation is successful. */

    func deQueue() -> Bool {
        if isEmpty() { return false }
        p_start = (p_start + 1) % len
        count -= 1
        return true
        
    }
    /** Get the front item from the queue. */

    func Front() -> Int {
        if isEmpty() {
            return -1
        }
        return data[p_start]
    }
    /** Get the last item from the queue. */

    func Rear() -> Int {
        if isEmpty() {
            return -1
        }
        let temp: Int = p_tail == 0 ? (len - 1) : (p_tail - 1)
        return data[temp]
    }
    /** Checks whether the circular queue is empty or not. */

    func isEmpty() -> Bool {
        return count == 0
    }
    /** Checks whether the circular queue is full or not. */

    func isFull() -> Bool {
        return count == len
    }
}

/**
 * Your MyCircularQueue object will be instantiated and called as such:
 * let obj = MyCircularQueue(k)
 * let ret_1: Bool = obj.enQueue(value)
 * let ret_2: Bool = obj.deQueue()
 * let ret_3: Int = obj.Front()
 * let ret_4: Int = obj.Rear()
 * let ret_5: Bool = obj.isEmpty()
 * let ret_6: Bool = obj.isFull()
 */

---

204ms

class MyCircularQueue {
    var maxQueueSize: Int
    var circleQueue: Array<Int>
    var head: Int
    var rear: Int
    let maxValue = 1000
    
    /** Initialize your data structure here. Set the size of the queue to be k. */
    init(_ k: Int) {
        maxQueueSize = k
        circleQueue = Array(repeating: -1, count: k)
        head = -1
        rear = -1
    }
    
    /** Insert an element into the circular queue. Return true if the operation is successful. */
    func enQueue(_ value: Int) -> Bool {
        if value < 0 || value > maxValue {
            return false
        }
        
        if isFull() {
            return false
        }
        
        if isEmpty() {
            head = 0
        }
        
        rear = (rear + 1) % maxQueueSize
        circleQueue[rear] = value
        return true
    }
    
    /** Delete an element from the circular queue. Return true if the operation is successful. */
    func deQueue() -> Bool {
        if isEmpty() {
            return false
        }
        
        if head == rear {
            head = -1
            rear = -1
            return true
        }
        
        head = (head + 1) % maxQueueSize
        return true
    }
    
    /** Get the front item from the queue. */
    func Front() -> Int {
        if isEmpty() {
            return -1
        }
        return circleQueue[head]
    }
    
    /** Get the last item from the queue. */
    func Rear() -> Int {
        if isEmpty() {
            return -1
        }
        return circleQueue[rear]
    }
    
    /** Checks whether the circular queue is empty or not. */
    func isEmpty() -> Bool {
        return head == -1
    }
    
    /** Checks whether the circular queue is full or not. */
    func isFull() -> Bool {
        return head == (rear + 1) % maxQueueSize
    }
}

---

236ms

class MyCircularQueue {
    
    var arr:Array<Int>?
    var head:Int = -1
    var tail:Int = -1
    var size:Int?

    /** Initialize your data structure here. Set the size of the queue to be k. */
    init(_ k: Int) {
        arr = Array.init(repeating: 0, count: k)
        size = k
    }
    /** Insert an element into the circular queue. Return true if the operation is successful. */

    func enQueue(_ value: Int) -> Bool {
        if isFull() == true {
            return false
        }
        
        if isEmpty() == true{
            head = 0
        }
        tail = (tail + 1) % size!
        arr![tail] = value
        return true
    }
    /** Delete an element from the circular queue. Return true if the operation is successful. */

    func deQueue() -> Bool {
        if isEmpty() == true{
            return false
        }
        
        if head == tail{
            head = -1
            tail = -1
            return true
        }
        head = (head + 1) % size!
        return true
    }
    /** Get the front item from the queue. */

    func Front() -> Int {
        if isEmpty() == true{
            return -1
        }
        return arr![head]
    }
    /** Get the last item from the queue. */

    func Rear() -> Int {
        if isEmpty() == true {
            return -1
        }
        return arr![tail]
    }
    /** Checks whether the circular queue is empty or not. */

    func isEmpty() -> Bool {
        return head == -1
    }
    /** Checks whether the circular queue is full or not. */

    func isFull() -> Bool {
        return ((tail + 1) % size!) == head
    }
}