DSA Linked Lists Types

Linked Lists are one of the most powerful data structures in DSA because they connect data dynamically in memory using nodes and pointers.

Unlike arrays, they don’t need contiguous memory — instead, each node stores its own data and the address (or link) to another node.

In this lesson, let’s explore the types of Linked Lists and visualize how they’re connected in memory with GoNimbus Visualizer!

---

🔹 1. Singly Linked List

A Singly Linked List is the simplest type.
Each node stores:

• Data
• Pointer (Next) → points to the next node.

The last node points to NULL, marking the end of the list.

📘 Example Visualization

[3 | ●] → [5 | ●] → [13 | ●] → [2 | NULL]

🧩 Memory Insight:
Each node can live anywhere in memory — pointers keep them connected!

💡 GoNimbus Tip:
Run the “Forward Traversal” animation to see how each pointer moves through memory step by step.

Python Example:

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

node1 = Node(3)
node2 = Node(5)
node3 = Node(13)
node4 = Node(2)

node1.next = node2
node2.next = node3
node3.next = node4

current = node1
while current:
    print(current.data, end=" -> ")
    current = current.next
print("NULL")

---

🔹 2. Doubly Linked List

A Doubly Linked List (DLL) is a bidirectional chain.
Each node stores:

• Data
• Prev pointer → points to the previous node.
• Next pointer → points to the next node.

📘 Example Visualization

NULL ← [3 | ● | ●] ↔ [5 | ● | ●] ↔ [13 | ● | ●] ↔ [2 | ● | NULL]

🧩 Why it matters:

• Can move forward and backward.
• Uses more memory but increases flexibility.

💡 GoNimbus Tip:
Use “Traverse Backward” in the visualizer to move from tail to head.

Python Example:

class Node:
    def __init__(self, data):
        self.data = data
        self.prev = None
        self.next = None

node1 = Node(3)
node2 = Node(5)
node3 = Node(13)
node4 = Node(2)

node1.next = node2
node2.prev = node1
node2.next = node3
node3.prev = node2
node3.next = node4
node4.prev = node3

---

🔹 3. Circular Singly Linked List

In a Circular Singly Linked List, the last node points back to the first node, forming a closed loop.

📘 Example Visualization

[3 | ●] → [5 | ●] → [13 | ●] → [2 | ●]
         ↑_____________________________|

🧩 Why use it:

• Great for tasks that cycle repeatedly (like round-robin scheduling).
• No “end” — traversal continues infinitely unless stopped manually.

💡 GoNimbus Tip:
In the “Loop Mode”, see the continuous traversal animation to understand the cycle.

Python Example:

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

node1 = Node(3)
node2 = Node(5)
node3 = Node(13)
node4 = Node(2)

node1.next = node2
node2.next = node3
node3.next = node4
node4.next = node1  # makes it circular

---

🔹 4. Circular Doubly Linked List

This is the most flexible version!
A Circular Doubly Linked List connects both forward and backward, and the head and tail are linked together.

📘 Example Visualization

↻ [3] ↔ [5] ↔ [13] ↔ [2] ↻

🧩 Why use it:

• Enables continuous movement in both directions.
• Ideal for music playlists, buffer systems, or task scheduling.

💡 GoNimbus Tip:
Try the “Dual Traversal Mode” to watch how both forward and backward connections move in sync.

Python Example:

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
        self.prev = None

node1 = Node(3)
node2 = Node(5)
node3 = Node(13)
node4 = Node(2)

node1.next = node2
node1.prev = node4
node2.prev = node1
node2.next = node3
node3.prev = node2
node3.next = node4
node4.prev = node3
node4.next = node1

---

🧩 Summary Table

Type	Links	Direction	Circular?	Memory Use	Traversal
Singly Linked List	1 (next)	Forward only	❌	Low	Easy
Doubly Linked List	2 (prev + next)	Forward & Backward	❌	Moderate	Flexible
Circular Singly	1 (next)	Forward only	✅	Low	Continuous
Circular Doubly	2 (prev + next)	Forward & Backward	✅	High	Continuous

---

🧠 Key Takeaway

Every Linked List type has its own balance between memory and flexibility.
Choose based on whether you need single-direction traversal, bidirectional movement, or continuous looping.

---

🧮 GoNimbus Exercise

🧩 Challenge:
You have a Singly Linked List with nodes:

[3] → [5] → [13] → [2]

How can you make it circular?

💭 Hint: Connect the next pointer of the last node back to the head.

✅ Answer:
node4.next = node1

---