Queues for Complete Beginners

A queue stores items in the order they arrive. The first item added is the first item removed. This is called FIFO (First In, First Out) like a line at a store where the first person to arrive is served first.

JavaScript Implementation


// Queue using an internal array (FIFO)
class Queue {
  constructor() {
    this._items = []; // holds the queue elements
  }

  // Add an element to the end
  enqueue(value) {
    this._items.push(value);
  }

  // Remove and return the front element
  // Returns null if the queue is empty
  dequeue() {
    if (this.isEmpty()) return null;
    return this._items.shift();
  }

  // View the front element without removing it
  peek() {
    if (this.isEmpty()) return null;
    return this._items[0];
  }

  // Is the queue empty?
  isEmpty() {
    return this._items.length === 0;
  }

  // Number of elements in the queue
  size() {
    return this._items.length;
  }

  // Remove all elements
  clear() {
    this._items = [];
  }

  // Show contents (for learning/demo)
  print() {
    return this._items.join(", ");
  }
}

// Example usage
const q = new Queue();
q.enqueue("apple");
q.enqueue("banana");
q.enqueue("cherry");

console.log("Front:", q.peek());     // apple
console.log("Size:", q.size());      // 3
console.log("All:", q.print());      // apple, banana, cherry

console.log("Dequeue:", q.dequeue()); // apple
console.log("Front now:", q.peek());  // banana
console.log("Empty?", q.isEmpty());   // false

q.clear();
console.log("After clear, size:", q.size()); // 0

Complete Explanation of the Code

class Queue: Defines a blueprint for creating queue objects that support common queue actions.
constructor(): Runs once when a queue is created. It initializes this._items as an empty array to store the elements.
enqueue(value): Adds a new item to the back of the queue using Array.push. This matches “join the end of the line.”
dequeue(): If the queue is empty, returns null. Otherwise removes the first item with Array.shift and returns it the front of the line is served first.
peek(): If empty, returns null. Otherwise returns the first item without removing it, letting you see who is next.
isEmpty(): Returns true when there are zero items and false otherwise, using the array’s length.
size(): Returns the number of stored items by reading this._items.length.
clear(): Resets the queue to empty by assigning a new empty array.
print(): Helper for learning; joins items with commas so you can view the queue’s contents easily.
Example usage: Demonstrates adding items, checking the front, size, printing all items, removing the front, and clearing the queue.

Performance Note: Using Array.shift() moves all remaining elements and is typically O(n). For heavy-duty use, consider a head/tail index or a linked list to make dequeue O(1).

Standard Pseudocode


INITIALIZE QUEUE
  SET items TO an empty list

PROCEDURE ENQUEUE(value)
  APPEND value TO items
END PROCEDURE

FUNCTION DEQUEUE
  IF items is empty THEN
    RETURN null
  ELSE
    SET first TO items[0]
    REMOVE items[0] FROM items
    RETURN first
  END IF
END FUNCTION

FUNCTION PEEK
  IF items is empty THEN
    RETURN null
  ELSE
    RETURN items[0]
  END IF
END FUNCTION

FUNCTION ISEMPTY
  IF length of items = 0 THEN
    RETURN true
  ELSE
    RETURN false
  END IF
END FUNCTION

FUNCTION SIZE
  RETURN length of items
END FUNCTION

PROCEDURE CLEAR
  SET items TO an empty list
END PROCEDURE

Explanation of the Pseudocode

INITIALIZE QUEUE: Prepares an empty list named items to hold the data.
ENQUEUE: APPEND puts the new value at the end, matching “join the line.”
DEQUEUE: If no items exist, RETURN null. Otherwise take the first item (items[0]), remove it from the list, and RETURN it.
PEEK: Shows the front item without removing it; if empty, returns null.
ISEMPTY: Checks whether the list length equals zero and returns true or false.
SIZE: Returns how many items are currently stored.
CLEAR: Empties the structure by setting items to a new empty list.