DSA Linked Lists Types

🔗 DSA Linked Lists Types

A Linked List is a dynamic data structure made of nodes, where each node stores:

Data
Link(s) to other node(s)

Below are the main types of Linked Lists asked in DSA exams & interviews, with easy explanations and example code.

1️⃣ Singly Linked List (SLL)

Definition

Each node contains:

Data
Pointer to the next node only

Traversal is one-directional.

Structure

Example Code (C++)

#include <iostream>
using namespace std;

struct Node {
int data;
Node* next;
};

int main() {
Node* head = new Node();
Node* second = new Node();
Node* third = new Node();

head->data = 10;
head->next = second;

second->data = 20;
second->next = third;

third->data = 30;
third->next = NULL;

Node* temp = head;
while(temp != NULL) {
cout << temp->data << " ";
temp = temp->next;
}

return 0;
}

#include <iostream>

using namespace std;

struct Node {

int data;

Node* next;

};

int main() {

Node* head = new Node();

Node* second = new Node();

Node* third = new Node();

head->data = 10;

head->next = second;

second->data = 20;

second->next = third;

third->data = 30;

third->next = NULL;

Node* temp = head;

while(temp != NULL) {

cout << temp->data << " ";

temp = temp->next;

}

return 0;

}

Output

Key Points

✔ Simple structure
✔ Low memory usage
❌ Cannot traverse backward

2️⃣ Doubly Linked List (DLL)

Definition

Each node contains:

Data
Pointer to previous node
Pointer to next node

Traversal is both directions.

Structure

Example Code (C++)

#include <iostream>
using namespace std;

struct Node {
int data;
Node* prev;
Node* next;
};

int main() {
Node* head = new Node();
Node* second = new Node();
Node* third = new Node();

head->data = 10;
head->prev = NULL;
head->next = second;

second->data = 20;
second->prev = head;
second->next = third;

third->data = 30;
third->prev = second;
third->next = NULL;

Node* temp = head;
while(temp != NULL) {
cout << temp->data << " ";
temp = temp->next;
}

return 0;
}

#include <iostream>

using namespace std;

struct Node {

int data;

Node* prev;

Node* next;

};

int main() {

Node* head = new Node();

Node* second = new Node();

Node* third = new Node();

head->data = 10;

head->prev = NULL;

head->next = second;

second->data = 20;

second->prev = head;

second->next = third;

third->data = 30;

third->prev = second;

third->next = NULL;

Node* temp = head;

while(temp != NULL) {

cout << temp->data << " ";

temp = temp->next;

}

return 0;

}

Output

Key Points

✔ Forward & backward traversal
✔ Easy deletion
❌ Extra memory for prev pointer

3️⃣ Circular Linked List (CLL)

Definition

Last node points back to the first node
No NULL pointer

Structure

Example Code (C++)

#include <iostream>
using namespace std;

struct Node {
int data;
Node* next;
};

int main() {
Node* head = new Node();
Node* second = new Node();
Node* third = new Node();

head->data = 10;
head->next = second;

second->data = 20;
second->next = third;

third->data = 30;
third->next = head; // circular link

Node* temp = head;
do {
cout << temp->data << " ";
temp = temp->next;
} while(temp != head);

return 0;
}

#include <iostream>

using namespace std;

struct Node {

int data;

Node* next;

};

int main() {

Node* head = new Node();

Node* second = new Node();

Node* third = new Node();

head->data = 10;

head->next = second;

second->data = 20;

second->next = third;

third->data = 30;

third->next = head; // circular link

Node* temp = head;

do {

cout << temp->data << " ";

temp = temp->next;

} while(temp != head);

return 0;

}

Output

Key Points

✔ No NULL pointers
✔ Efficient for circular tasks
❌ Careful traversal needed (avoid infinite loop)

4️⃣ Circular Doubly Linked List (CDLL) (Advanced)

Definition

Doubly linked list
Last node points to first
First node points back to last

Structure

Example Code (C++)

#include <iostream>
using namespace std;

struct Node {
int data;
Node* prev;
Node* next;
};

int main() {
Node* head = new Node();
Node* second = new Node();

head->data = 10;
head->next = second;
head->prev = second;

second->data = 20;
second->next = head;
second->prev = head;

Node* temp = head;
do {
cout << temp->data << " ";
temp = temp->next;
} while(temp != head);

return 0;
}

#include <iostream>

using namespace std;

struct Node {

int data;

Node* prev;

Node* next;

};

int main() {

Node* head = new Node();

Node* second = new Node();

head->data = 10;

head->next = second;

head->prev = second;

second->data = 20;

second->next = head;

second->prev = head;

Node* temp = head;

do {

cout << temp->data << " ";

temp = temp->next;

} while(temp != head);

return 0;

}

Comparison of Linked List Types

Type	Direction	NULL Pointer	Extra Memory
Singly	One-way	Yes	Low
Doubly	Two-way	Yes	High
Circular	One-way	No	Medium
Circular Doubly	Two-way	No	High

Interview-Focused Questions

Q1. Which linked list allows backward traversal?
👉 Doubly Linked List

Q2. Which linked list has no NULL pointer?
👉 Circular Linked List

Q3. Which uses more memory?
👉 Doubly Linked List

Q4. Best linked list for round-robin scheduling?
👉 Circular Linked List

Final Summary

✔ Linked lists are dynamic
✔ Nodes connected using pointers
✔ Four main types used in DSA
✔ Singly = simple
✔ Doubly = flexible
✔ Circular = continuous traversal
✔ Very important for exams & interviews

DSA Linked Lists Types