Arrays are great for fast access…
But inserting or deleting elements can be expensive.
That’s where Linked Lists become powerful.
A Singly Linked List connects nodes like a chain:
- each node points only to the next node.
1. Structure of a Singly Linked List
Visual representation:
[10] → [20] → [30] → null
Each node contains:
- data
- reference to next node
2. Insert at Head
Idea
New node becomes the first node.
public void insertAtHead(int data) {
Node newNode = new Node(data);
newNode.next = head;
head = newNode;
}
Complexity
O(1) insertion at head
Because:
- no traversal needed
3. Insert at End
Idea
Traverse until last node.
public void insertAtEnd(int data) {
Node newNode = new Node(data);
if (head == null) {
head = newNode;
return;
}
Node temp = head;
while (temp.next != null) {
temp = temp.next;
}
temp.next = newNode;
}
Complexity
O(n) insertion at end
Because:
- traversal is required.
4. Delete a Node
Idea
Find previous node,
then bypass target node.
public void delete(int key) {
if (head == null)
return;
if (head.data == key) {
head = head.next;
return;
}
Node temp = head;
while (temp.next != null &&
temp.next.data != key) {
temp = temp.next;
}
if (temp.next != null) {
temp.next = temp.next.next;
}
}
5. Traversal
Idea
Move node by node until null.
public void printList() {
Node temp = head;
while (temp != null) {
System.out.print(temp.data + " -> ");
temp = temp.next;
}
System.out.println("null");
}
Linked Lists trade:
- random access
for:
- flexible insertions/deletions
That’s their main strength.
- Nodes form a one-way chain
- Head stores first node
- Insert at head → O(1)
- Traversal → O(n)
Singly Linked Lists are one of the most important DSA foundations.
Understanding them deeply makes advanced structures much easier
Explore More: https://www.quipoin.com/tutorial/data-structure-with-java/singly-linked-list