Circular vs Linear Linked List Key Difference in DSA Javascript - Compare & Choose

Challenge - 5 Problems

🧠 Conceptual

intermediate

Key difference between Circular and Linear Linked Lists

Which statement best describes the key difference between a circular linked list and a linear linked list?

A In a circular linked list, nodes are stored in a circle shape in memory; in a linear linked list, nodes are stored in a straight line in memory.

B A circular linked list can only have even number of nodes; a linear linked list can have any number of nodes.

C In a circular linked list, the last node points back to the first node; in a linear linked list, the last node points to null.

D In a circular linked list, nodes contain two data fields; in a linear linked list, nodes contain only one data field.

💡 Hint

Think about how the last node connects in each list type.

The main difference is how the last node links. In a circular linked list, the last node points back to the first node, creating a loop. In a linear linked list, the last node points to null, marking the end.

❓ Predict Output

intermediate

Output of traversing a circular linked list

Consider this JavaScript code that creates a circular linked list with 3 nodes and traverses it once. What is the printed output?

DSA Javascript

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

const node1 = new Node(1);
const node2 = new Node(2);
const node3 = new Node(3);

node1.next = node2;
node2.next = node3;
node3.next = node1; // circular link

let current = node1;
let count = 0;
let output = '';
while (count < 3) {
  output += current.value + ' -> ';
  current = current.next;
  count++;
}
output += 'null';
console.log(output);

A 1 -> 2 -> 3 -> null

B 1 -> 2 -> 3 -> 1 -> null

C 1 -> 2 -> 3 -> 3 -> null

D 1 -> 2 -> 3 -> 1 -> 2 -> 3 -> null

💡 Hint

The loop runs exactly 3 times, printing each node once.

The code traverses exactly 3 nodes starting from node1. It prints values 1, 2, 3 followed by 'null'. Even though the list is circular, the loop stops after 3 iterations.

❓ Predict Output

advanced

Output of traversing a linear linked list with 3 nodes

What will be the output of this JavaScript code that creates a linear linked list and traverses it?

DSA Javascript

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

const node1 = new Node(1);
const node2 = new Node(2);
const node3 = new Node(3);

node1.next = node2;
node2.next = node3;
node3.next = null; // linear end

let current = node1;
let output = '';
while (current !== null) {
  output += current.value + ' -> ';
  current = current.next;
}
output += 'null';
console.log(output);

A 1 -> 2 -> 3 -> null

B 1 -> 2 -> 3 -> 1 -> null

C 1 -> 2 -> null

D 1 -> null

💡 Hint

The loop continues until current is null, printing all nodes.

The code prints all nodes in the linear linked list: 1, 2, 3, then 'null' to mark the end.

🧠 Conceptual

advanced

Why circular linked lists are useful

Which of the following is the best reason to use a circular linked list instead of a linear linked list?

A To ensure the list always has an even number of nodes.

B To save memory by not storing null at the end of the list.

C To prevent any node from being accessed more than once.

D To easily loop through the list multiple times without restarting from the head manually.

💡 Hint

Think about how the last node connects back to the first node.

Circular linked lists allow continuous traversal without needing to reset to the head manually, making repeated looping easier.

🔧 Debug

expert

Identify the error in circular linked list traversal

What error will occur when running this code that tries to traverse a circular linked list without a stopping condition?

DSA Javascript

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

const node1 = new Node(1);
const node2 = new Node(2);
const node3 = new Node(3);

node1.next = node2;
node2.next = node3;
node3.next = node1; // circular link

let current = node1;
while (current !== null) {
  console.log(current.value);
  current = current.next;
}

A The code will throw a TypeError because current.next is undefined.

B The code will run infinitely, printing 1, 2, 3 repeatedly without stopping.

C The code will print only 1 and then stop.

D The code will throw a SyntaxError due to missing semicolons.

💡 Hint

Consider what happens when the list loops back to the first node.

The loop condition checks for current !== null, but in a circular linked list, current never becomes null. This causes an infinite loop printing 1, 2, 3 repeatedly.

Practice

1. What is the main difference between a circular linked list and a linear linked list?

easy

A. In a circular linked list, the last node points back to the first node; in a linear linked list, the last node points to null.

B. In a linear linked list, nodes form a circle; in a circular linked list, nodes end with null.

C. Circular linked lists store data in a circle shape; linear linked lists store data in a straight line.

D. Circular linked lists use arrays internally; linear linked lists use pointers.

Solution

1. Step 1: Understand the pointer of the last node in linear linked list

   In a linear linked list, the last node's next pointer is null, indicating the end of the list.

2. Step 2: Understand the pointer of the last node in circular linked list

   In a circular linked list, the last node's next pointer points back to the first node, forming a circle.

3. Final Answer:

   In a circular linked list, the last node points back to the first node; in a linear linked list, the last node points to null. -> Option A

4. Quick Check:

   Last node pointer difference = In a circular linked list, the last node points back to the first node; in a linear linked list, the last node points to null. [OK]

Hint: Last node points null in linear, loops to head in circular [OK]

Common Mistakes:

• Confusing the direction of pointers in circular vs linear
• Thinking circular lists end with null
• Assuming circular lists use arrays internally

2. Which of the following is the correct way to check if a linked list is circular in JavaScript?

easy

A. if (head.next === head) { /* circular list */ } else if (head.next === null) { /* linear list */ }

B. if (head === null) { /* empty list */ } else if (head.next === head) { /* circular list */ }

C. if (head.next === null) { /* linear list */ } else { /* circular list */ }

D. if (head.next === undefined) { /* circular list */ }

Solution

1. Step 1: Check the next pointer of head node

   If head.next points to head itself, it means the list is circular with one node.

2. Step 2: Check if next pointer is null for linear list

   If head.next is null, it means the list ends there, so it is linear.

3. Final Answer:

   if (head.next === head) { /* circular list */ } else if (head.next === null) { /* linear list */ } -> Option A

4. Quick Check:

   Check next pointer for circular or null for linear [OK]

Hint: Check if next points to head for circular, null for linear [OK]

Common Mistakes:

• Checking undefined instead of null
• Assuming head.next null means circular
• Not handling empty list (head null) case

3. Consider the following JavaScript code for a circular linked list with three nodes. What will be the output when traversing and printing the list once starting from head?

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

const head = new Node(1);
const second = new Node(2);
const third = new Node(3);

head.next = second;
second.next = third;
third.next = head; // circular link

let current = head;
let output = '';
do {
  output += current.data + ' -> ';
  current = current.next;
} while (current !== head);
output += 'null';
console.log(output);

medium

A. Infinite loop, no output

B. 1 -> 2 -> 3 -> 1 -> 2 -> 3 -> null

C. 1 -> 2 -> 3 -> 1 -> null

D. 1 -> 2 -> 3 -> null

Solution

1. Step 1: Understand the circular linked list structure

   The last node points back to the head, creating a loop: 1 -> 2 -> 3 -> 1 ...

2. Step 2: Trace the traversal loop once

   The do-while loop prints nodes starting at head and stops when it reaches head again after one full cycle, printing "1 -> 2 -> 3 -> null".

3. Final Answer:

   1 -> 2 -> 3 -> null -> Option D

4. Quick Check:

   Traverse once until back to head = 1 -> 2 -> 3 -> null [OK]

Hint: Traverse until current equals head again to print once [OK]

Common Mistakes:

• Thinking loop prints infinitely
• Appending extra nodes after stopping
• Confusing do-while with while loop

4. The following code attempts to detect if a linked list is circular. What is the bug?

function isCircular(head) {
  let current = head;
  while (current !== null) {
    if (current.next === head) {
      return true;
    }
    current = current.next;
  }
  return false;
}

medium

A. It does not handle empty list (head null) case.

B. It incorrectly returns true for linear lists.

C. It may cause infinite loop if list has a cycle not pointing to head.

D. It uses strict equality instead of loose equality.

Solution

1. Step 1: Analyze the loop condition and pointer movement

   The loop moves through nodes until current is null, checking if current.next equals head.

2. Step 2: Identify the problem with cycles not pointing to head

   If the list has a cycle that does not point back to head, the loop never reaches null and never finds current.next === head, causing an infinite loop.

3. Final Answer:

   It may cause infinite loop if list has a cycle not pointing to head. -> Option C

4. Quick Check:

   Cycle detection fails if cycle not at head [OK]

Hint: Cycle may not point to head, causing infinite loop [OK]

Common Mistakes:

• Assuming all cycles point to head
• Not checking for null head before loop
• Confusing strict and loose equality

5. You have a linked list where the last node points back to the third node (not the head). Which type of linked list is this, and what is the key difference from a linear linked list?

hard

A. It is a linear linked list; the key difference is the last node points to the third node.

B. It is a circular linked list; the key difference is the last node points to a node inside the list, not null.

C. It is a doubly linked list; the key difference is nodes have two pointers.

D. It is a circular linked list; the key difference is the last node points to the head only.

Solution

1. Step 1: Identify the type of linked list by last node pointer

   The last node points back to the third node, creating a loop inside the list, which defines a circular linked list.

2. Step 2: Compare with linear linked list ending

   In a linear linked list, the last node points to null, marking the end. Here, the last node points inside the list, so it is circular.

3. Final Answer:

   It is a circular linked list; the key difference is the last node points to a node inside the list, not null. -> Option B

4. Quick Check:

   Last node points inside list = circular list [OK]

Hint: Last node points inside list means circular, not linear [OK]

Common Mistakes:

• Thinking only head pointer defines circular list
• Confusing doubly linked list with circular list
• Assuming last node must point to head for circular