Circular vs Linear Linked List Key Difference in DSA Java - Build Both Approaches

Circular vs Linear Linked List Key Difference

📖 Scenario: Imagine you are organizing a small music playlist. You want to understand two ways to connect songs: one where the last song points back to the first (like a loop), and one where the last song just ends the list.

🎯 Goal: You will create two simple linked lists in Java: one linear and one circular. You will see how the last node connects differently in each list.

📋 What You'll Learn

Create a linear linked list with three nodes containing values 10, 20, 30

Create a circular linked list with three nodes containing values 10, 20, 30

Show how the last node points to null in linear list

Show how the last node points back to the first node in circular list

Print the nodes of both lists to demonstrate the difference

💡 Why This Matters

🌍 Real World

Circular linked lists are used in music playlists, round-robin scheduling, and games where you cycle through players repeatedly. Linear linked lists are used in simple data storage where the end is clear.

💼 Career

Understanding linked list types is important for software developers working on data structures, memory management, and algorithms that require efficient looping or termination.

1

Create a linear linked list with three nodes

Create a class called Node with an int data and a Node next. Then create three nodes with values 10, 20, and 30. Link them linearly so the last node's next is null. Store the first node in a variable called linearHead.

DSA Java

// Define Node class
class Node {
    int data;
    Node next;
    Node(int data) {
        this.data = data;
        this.next = null;
    }
}

// Create linear linked list nodes
// Your code here

Hint

Remember to link each node's next to the following node, and the last node's next should be null.

2

Create a circular linked list with three nodes

Using the same Node class, create three new nodes with values 10, 20, and 30. Link them so the last node's next points back to the first node, forming a circle. Store the first node in a variable called circularHead.

DSA Java

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

Node node1 = new Node(10);
Node node2 = new Node(20);
Node node3 = new Node(30);
node1.next = node2;
node2.next = node3;
node3.next = null;
Node linearHead = node1;

// Create circular linked list nodes
// Your code here

Hint

Make sure the last node's next points back to the first node to form a circle.

3

Write methods to print both lists

Write a method called printLinearList that takes Node linearHead and prints the data of each node until null. Write another method called printCircularList that takes Node circularHead and prints the data of each node once, stopping when it reaches the start node again. Use for or while loops with variables named current.

DSA Java

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

Node node1 = new Node(10);
Node node2 = new Node(20);
Node node3 = new Node(30);
node1.next = node2;
node2.next = node3;
node3.next = null;
Node linearHead = node1;

Node cnode1 = new Node(10);
Node cnode2 = new Node(20);
Node cnode3 = new Node(30);
cnode1.next = cnode2;
cnode2.next = cnode3;
cnode3.next = cnode1;
Node circularHead = cnode1;

// Write printLinearList method
// Write printCircularList method
// Your code here

Hint

For the circular list, use a do-while loop to print nodes until you reach the start node again.

4

Print both lists to show the difference

Call printLinearList(linearHead) and printCircularList(circularHead) to print the nodes of both lists. This will show how the linear list ends with null and the circular list loops back to the start.

DSA Java

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

Node node1 = new Node(10);
Node node2 = new Node(20);
Node node3 = new Node(30);
node1.next = node2;
node2.next = node3;
node3.next = null;
Node linearHead = node1;

Node cnode1 = new Node(10);
Node cnode2 = new Node(20);
Node cnode3 = new Node(30);
cnode1.next = cnode2;
cnode2.next = cnode3;
cnode3.next = cnode1;
Node circularHead = cnode1;

void printLinearList(Node linearHead) {
    Node current = linearHead;
    while (current != null) {
        System.out.print(current.data + " -> ");
        current = current.next;
    }
    System.out.println("null");
}

void printCircularList(Node circularHead) {
    if (circularHead == null) return;
    Node current = circularHead;
    do {
        System.out.print(current.data + " -> ");
        current = current.next;
    } while (current != circularHead);
    System.out.println("(back to start)");
}

// Call print methods below
// Your code here

Hint

Call the print methods with the correct head nodes to see the difference in output.

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, forming a circle.

B. In a linear linked list, the last node points back to the first node, forming a circle.

C. A circular linked list has no nodes.

D. A linear linked list always has only one node.

Solution

1. Step 1: Understand the structure of a circular linked list

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

2. Step 2: Compare with linear linked list

   In a linear linked list, the last node points to null, so it does not form a loop.

3. Final Answer:

   In a circular linked list, the last node points back to the first node, forming a circle. -> Option A

4. Quick Check:

   Circular list loops back [OK]

Hint: Circular loops back to start; linear ends with null [OK]

Common Mistakes:

• Confusing which list forms a loop
• Thinking linear list loops back
• Assuming circular list has no nodes

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

easy

A. if (head != null && head.next != null && head.next == head) { /* circular */ }

B. if (head.next == head) { /* circular */ }

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

D. if (head == null) { /* circular */ }

Solution

1. Step 1: Understand circular list check

   In a circular linked list, the last node's next points back to the head node.

2. Step 2: Identify correct condition

   Checking if head.next == head means the list loops back immediately, indicating circularity, but we must also ensure head and head.next are not null to avoid NullPointerException.

3. Final Answer:

   if (head != null && head.next != null && head.next == head) { /* circular */ } -> Option A

4. Quick Check:

   Last node points to head with null checks [OK]

Hint: Check if next points to head for circular list with null safety [OK]

Common Mistakes:

• Checking null instead of loop
• Confusing head and next pointers
• Using incomplete conditions

3. What will be the output of the following Java code snippet?

class Node {
  int data;
  Node next;
  Node(int d) { data = d; next = null; }
}

public class Test {
  public static void main(String[] args) {
    Node head = new Node(1);
    Node second = new Node(2);
    Node third = new Node(3);
    head.next = second;
    second.next = third;
    third.next = head; // circular link

    Node temp = head;
    int count = 0;
    while (temp != null && count < 5) {
      System.out.print(temp.data + " ");
      temp = temp.next;
      count++;
    }
  }
}

medium

A. 1 2 3 1 2 3

B. 1 2 3

C. 1 2 3 1 2

D. 1 2 3 3 2

Solution

1. Step 1: Understand the linked list structure

   Nodes 1, 2, 3 are linked linearly, then third node points back to head, making it circular.

2. Step 2: Trace the loop with count limit

   Loop prints node data 5 times: 1, 2, 3, then back to 1, then 2.

3. Final Answer:

   1 2 3 1 2 -> Option C

4. Quick Check:

   5 nodes printed in circular order [OK]

Hint: Count limits circular print to avoid infinite loop [OK]

Common Mistakes:

• Assuming loop stops at null in circular list
• Printing extra nodes beyond count
• Confusing node data order

4. Identify the error in the following code snippet that tries to create a circular linked list:

Node head = new Node(10);
Node second = new Node(20);
head.next = second;
second.next = null; // supposed to make circular

medium

A. head.next should be null to make the list circular.

B. second.next should point to head to make the list circular.

C. Nodes cannot form a circular linked list.

D. second node should not be created separately.

Solution

1. Step 1: Check the pointer assignments

   second.next is set to null, so it does not loop back to head.

2. Step 2: Correct the circular link

   To make the list circular, second.next must point to head node.

3. Final Answer:

   second.next should point to head to make the list circular. -> Option B

4. Quick Check:

   Last node points to head for circular [OK]

Hint: Last node must link to head for circular list [OK]

Common Mistakes:

• Setting last node next to null
• Confusing which node to link back
• Thinking circular list needs no links

5. You want to traverse a circular linked list with unknown length safely in Java. Which approach is best to avoid infinite loops?

hard

A. Traverse until current node's data equals zero.

B. Traverse until current node is null.

C. Traverse a fixed number of nodes, assuming list size is known.

D. Traverse until current node equals the head node again after first visit.

Solution

1. Step 1: Understand circular list traversal

   In circular lists, nodes never point to null, so null check won't stop traversal.

2. Step 2: Use head node as stopping condition

   Stop traversal when current node comes back to head after first visit to avoid infinite loop.

3. Final Answer:

   Traverse until current node equals the head node again after first visit. -> Option D

4. Quick Check:

   Stop when back at head [OK]

Hint: Stop when you reach head again to avoid infinite loop [OK]

Common Mistakes:

• Checking for null in circular list
• Assuming fixed size without knowing it
• Using data value as stop condition