Enqueue Using Linked List in DSA Javascript - Time & Space Complexity

Time Complexity: Enqueue Using Linked List

O(1)

Understanding Time Complexity

We want to understand how the time to add an item to a queue using a linked list changes as the queue grows.

How does the number of steps grow when we add more items?

Scenario Under Consideration

Analyze the time complexity of the enqueue operation using a linked list.

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

class Queue {
  constructor() {
    this.front = null;
    this.rear = null;
  }

  enqueue(value) {
    const newNode = new Node(value);
    if (!this.rear) {
      this.front = newNode;
      this.rear = newNode;
    } else {
      this.rear.next = newNode;
      this.rear = newNode;
    }
  }
}
    

This code adds a new item to the end of a queue implemented with a linked list.

Identify Repeating Operations

Look for loops or repeated steps inside the enqueue method.

• Primary operation: Adding a new node and updating pointers.
• How many times: This happens once per enqueue call, no loops involved.

How Execution Grows With Input

Each enqueue adds one node by updating a few pointers, no matter how big the queue is.

Input Size (n)	Approx. Operations
10	About 3 pointer updates
100	About 3 pointer updates
1000	About 3 pointer updates

Pattern observation: The number of steps stays the same no matter how many items are in the queue.

Final Time Complexity

Time Complexity: O(1)

This means adding an item takes the same small amount of time, no matter how big the queue is.

Common Mistake

[X] Wrong: "Enqueue takes longer as the queue grows because we have to find the end each time."

[OK] Correct: We keep a pointer to the end (rear), so we add directly without searching, keeping time constant.

Interview Connect

Knowing that enqueue in a linked list queue is fast and constant time shows you understand efficient data structure design, a key skill in coding interviews.

Self-Check

"What if we did not keep a rear pointer and had to find the end each time? How would the time complexity change?"

Practice

1. What does the enqueue operation do in a queue implemented using a linked list?

easy

A. Deletes the entire linked list

B. Removes an element from the front (head) of the linked list

C. Adds a new element at the end (tail) of the linked list

D. Adds a new element at the front (head) of the linked list

Solution

1. Step 1: Understand enqueue operation

   Enqueue means adding an element to the queue.

2. Step 2: Identify position in linked list

   In a linked list queue, new elements are added at the tail (end).

3. Final Answer:

   Adds a new element at the end (tail) of the linked list -> Option C

4. Quick Check:

   Enqueue = add at tail [OK]

Hint: Enqueue always adds at the tail in linked list queue [OK]

Common Mistakes:

• Confusing enqueue with dequeue operation
• Adding new element at the head instead of tail
• Thinking enqueue removes elements

2. Which of the following is the correct way to create a new node for enqueue in JavaScript linked list?

easy

A. const node = { value: val, next: null };

B. const node = new Node(val); node.next = val;

C. const node = { val: value, next: undefined };

D. const node = Node(val, null);

Solution

1. Step 1: Understand node structure

   A node should have a value and a pointer to next (null initially).

2. Step 2: Check syntax correctness

   const node = { value: val, next: null }; correctly creates an object with value and next set to null.

3. Final Answer:

   const node = { value: val, next: null }; -> Option A

4. Quick Check:

   Node = {{value, next:null}} [OK]

Hint: Node must have value and next=null for enqueue [OK]

Common Mistakes:

• Using wrong property names like 'val' instead of 'value'
• Setting next to undefined instead of null
• Calling Node as a function without new keyword

3. What will be the state of the queue after these operations?

enqueue(10); enqueue(20); enqueue(30);

Assuming an empty queue initially, what is the linked list representation?

medium

A. 10 -> 20 -> 30 -> null

B. 30 -> 20 -> 10 -> null

C. null -> 10 -> 20 -> 30

D. 20 -> 10 -> 30 -> null

Solution

1. Step 1: Enqueue 10

   Queue is empty, so 10 becomes head and tail: 10 -> null

2. Step 2: Enqueue 20 and 30

   20 added at tail: 10 -> 20 -> null, then 30 added: 10 -> 20 -> 30 -> null

3. Final Answer:

   10 -> 20 -> 30 -> null -> Option A

4. Quick Check:

   Order preserved, enqueue adds at tail [OK]

Hint: Enqueue adds at tail, order stays same [OK]

Common Mistakes:

• Reversing order of elements
• Confusing head and tail positions
• Assuming enqueue adds at head

4. Consider this enqueue function snippet:

function enqueue(val) {
  const node = { value: val, next: null };
  if (!this.tail) {
    this.head = node;
  }
  this.tail.next = node;
  this.tail = node;
}

What error will occur when enqueue is called on an empty queue?

medium

A. ReferenceError: this is not defined

B. SyntaxError: Unexpected token

C. No error, works fine

D. TypeError: Cannot read property 'next' of null

Solution

1. Step 1: Analyze empty queue condition

   When queue is empty, this.tail is null or undefined.

2. Step 2: Identify error line

   Code tries this.tail.next = node; but this.tail is null, causing TypeError.

3. Final Answer:

   TypeError: Cannot read property 'next' of null -> Option D

4. Quick Check:

   Accessing next on null causes TypeError [OK]

Hint: Check if tail exists before accessing next [OK]

Common Mistakes:

• Ignoring null check for tail
• Assuming no error on empty queue
• Confusing this.head and this.tail usage

5. You want to implement enqueue in a linked list queue that keeps track of both head and tail. Which of these code snippets correctly enqueues a new value val?

hard

A. const node = { value: val, next: null };
this.tail.next = node;
this.tail = node;

B. const node = { value: val, next: null };
if (!this.head) {
this.head = node;
this.tail = node;
} else {
this.tail.next = node;
this.tail = node;
}

C. const node = { value: val, next: this.head };
this.head = node;

D. const node = { value: val, next: null };
this.head.next = node;
this.head = node;

Solution

1. Step 1: Handle empty queue case

   If head is null, both head and tail should point to new node.

2. Step 2: Handle non-empty queue

   Set tail.next to new node and update tail to new node.

3. Final Answer:

   const node = { value: val, next: null }; if (!this.head) { this.head = node; this.tail = node; } else { this.tail.next = node; this.tail = node; } -> Option B

4. Quick Check:

   Check empty and non-empty cases for enqueue [OK]

Hint: Set head and tail on empty, else add at tail.next [OK]

Common Mistakes:

• Not updating tail on empty queue
• Adding new node at head instead of tail
• Forgetting to update tail pointer