Queue Implementation in Swift

1. Introduction

A Queue is a linear data structure that operates on a First In First Out (FIFO) principle. This means that the first element added to the queue will be the first one to be removed. Typical operations include enqueue (adding an item) and dequeue (removing the front item).

2. Implementation Steps

1. Define a Queue class or struct.

2. Use a private array to store the elements of the queue.

3. Implement a method enqueue to add an element to the end of the queue.

4. Implement a method dequeue to remove the front element of the queue. Return nil if the queue is empty.

5. Provide a method peek to view the front element without removing it.

6. Include a computed property isEmpty to check if the queue is empty.

3. Implementation in Swift

struct Queue<T> {
    private var elements: [T] = []
    // Enqueue: Add an item to the end of the queue
    mutating func enqueue(_ item: T) {
        elements.append(item)
    }
    // Dequeue: Remove the front item from the queue
    mutating func dequeue() -> T? {
        return isEmpty ? nil : elements.removeFirst()
    }
    // Peek: Look at the front item without removing it
    func peek() -> T? {
        return elements.first
    }
    // Check if the queue is empty
    var isEmpty: Bool {
        return elements.isEmpty
    }
}
// Example Usage
var stringQueue = Queue<String>()
stringQueue.enqueue("John")
stringQueue.enqueue("Doe")
stringQueue.enqueue("Smith")
print("After enqueues: \(stringQueue)")
print("Peek: \(stringQueue.peek() ?? "None")")
print("Dequeue: \(stringQueue.dequeue() ?? "None")")
print("After dequeue: \(stringQueue)")

Output:

After enqueues: Queue<String>(elements: ["John", "Doe", "Smith"])
Peek: John
Dequeue: John
After dequeue: Queue<String>(elements: ["Doe", "Smith"])

Explanation:

1. A Queue is implemented as a generic struct, allowing for flexibility in the types of elements it can store.

2. Within the Queue, a private array named elements is used to manage the elements.

3. The enqueue method appends an item to the end of the elements array.

4. The dequeue method removes and returns the first item from the elements array. If the queue is empty, it returns nil.

5. The peek method provides a way to see the first item without removing it.

6. The isEmpty computed property determines whether the elements array is empty, signifying the state of the queue.