There are various linked list operations that allow us to perform different actions on linked lists
For example, the insertion operation adds a new element to the linked list.
Here’s a list of Basic Operations in Linked List that we will cover in this article:

‣ Insertion: Adding a new element to the list.
- At the beginning: Inserting a new node at the beginning of the list.
- At the end: Inserting a new node at the end of the list.
- After a specific node: Inserting a new node after a given node in the list.
‣ Deletion: Removing an element from the list.
- From the beginning: Deleting the first node from the list.
- From the end: Deleting the last node from the list.
- A specific node: Deleting a node with a given value or a given position in the list.
‣ Traversal: Visiting each node in the list and performing some operation.
- Forward traversal: Starting from the head node and moving towards the tail node.
- Reverse traversal: Starting from the tail node and moving towards the head node.
Things to Remember about Linked List:
- head points to the first node of the linked list
- next pointer of the last node is NULL, so if the next current node is NULL, we have reached the end of the linked list.
Insertion in Linked list:
a. Method to insert data at the beginning of the linked list:
// Method to insert data at the beginning of the linked list
void insertAtBeginning(int data) {
Node newNode = new Node(data);
newNode.next = head;
head = newNode;
}
b. Method to insert data at the end of the linked list:
// Method to insert data at the end of the linked list
void insertAtEnd(int data) {
Node newNode = new Node(data);
if (head == null) {
head = newNode;
return;
}
Node current = head;
while (current.next != null) {
current = current.next;
}
current.next = newNode;
}
c. Method to insert data after a specific node in the linked list:
// Method to insert data after a specific node in the linked list
void insertAfterNode(Node prevNode, int data) {
if (prevNode == null) {
System.out.println("Previous node cannot be null.");
return;
}
Here’s the syntax for insertion of data in a singly linked list in Java:
class Node {
int data;
Node next;
Node(int data) {
this.data = data;
this.next = null;
}
}
class LinkedList {
Node head;
// Method to insert data at the beginning of the linked list
void insertAtBeginning(int data) {
Node newNode = new Node(data);
newNode.next = head;
head = newNode;
}
// Method to insert data at the end of the linked list
void insertAtEnd(int data) {
Node newNode = new Node(data);
if (head == null) {
head = newNode;
return;
}
Node current = head;
while (current.next != null) {
current = current.next;
}
current.next = newNode;
}
// Method to insert data after a specific node in the linked list
void insertAfterNode(Node prevNode, int data) {
if (prevNode == null) {
System.out.println("Previous node cannot be null.");
return;
}
Node newNode = new Node(data);
newNode.next = prevNode.next;
prevNode.next = newNode;
}
}
Deletion in Linked List:
a. Method to delete the first node from the linked list:
// Method to delete the first node from the linked list
public void deleteFirst() {
if (head == null)
return;
head = head.next;
}
b. Method to delete the last node from the linked list:
// Method to delete the last node from the linked list
public void deleteLast() {
if (head == null || head.next == null) {
head = null;
return;
}
Node temp = head;
while (temp.next.next != null) {
temp = temp.next;
}
temp.next = null;
}
c. Method to delete a node with a specific data value:
///Method to delete a node with a specific data value
public void deleteNode(int key) {
Node temp = head;
Node prev = null;
// If the node to be deleted is the head node
if (temp != null && temp.data == key) {
head = temp.next;
return;
}
Here’s a basic syntax for deletion operations in a singly linked list in Java:
class Node {
int data;
Node next;
public Node(int data) {
this.data = data;
this.next = null;
}
}
class LinkedList {
Node head;
// Method to delete the first node from the linked list
public void deleteFirst() {
if (head == null)
return;
head = head.next;
}
// Method to delete the last node from the linked list
public void deleteLast() {
if (head == null || head.next == null) {
head = null;
return;
}
Node temp = head;
while (temp.next.next != null) {
temp = temp.next;
}
temp.next = null;
}
// Method to delete a node with a specific data value
public void deleteNode(int key) {
Node temp = head;
Node prev = null;
// If the node to be deleted is the head node
if (temp != null && temp.data == key) {
head = temp.next;
return;
}
// Search for the node to be deleted, keeping track of the previous node
while (temp != null && temp.data != key) {
prev = temp;
temp = temp.next;
}
// If key was not present in the linked list
if (temp == null)
return;
// Unlink the node from the linked list
prev.next = temp.next;
}
}
Traversal in Linked list:
a. Method to traverse the linked list forward:
// Method to traverse the linked list forward
public void forwardTraversal() {
Node current = head;
System.out.print("Forward Traversal: ");
while (current != null) {
System.out.print(current.data + " ");
current = current.next;
}
System.out.println();
}
b. Method to traverse the linked list in reverse:
// Method to traverse the linked list in reverse
public void reverseTraversal() {
Node prev = null;
Node current = head;
Node next = null;
System.out.print("Reverse Traversal: ");
while (current != null) {
next = current.next;
current.next = prev;
prev = current;
current = next;
}
head = prev;
// Now head points to the last node
current = head;
while (current != null) {
System.out.print(current.data + " ");
current = current.next;
}
System.out.println();
}
Here’s a basic syntax for traversing a singly linked list in Java, both forward and reverse:
class Node {
int data;
Node next;
Node(int data) {
this.data = data;
this.next = null;
}
}
class LinkedList {
Node head;
// Method to traverse the linked list forward
public void forwardTraversal() {
Node current = head;
System.out.print("Forward Traversal: ");
while (current != null) {
System.out.print(current.data + " ");
current = current.next;
}
System.out.println();
}
// Method to traverse the linked list in reverse
public void reverseTraversal() {
Node prev = null;
Node current = head;
Node next = null;
System.out.print("Reverse Traversal: ");
while (current != null) {
next = current.next;
current.next = prev;
prev = current;
current = next;
}
head = prev;
// Now head points to the last node
current = head;
while (current != null) {
System.out.print(current.data + " ");
current = current.next;
}
System.out.println();
}
// Method to insert a new node at the end of the linked list
public void insert(int data) {
Node newNode = new Node(data);
if (head == null) {
head = newNode;
return;
}
Node current = head;
while (current.next != null) {
current = current.next;
}
current.next = newNode;
}
}
public class Main {
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.insert(1);
list.insert(2);
list.insert(3);
list.insert(4);
// Forward traversal
list.forwardTraversal();
// Reverse traversal
list.reverseTraversal();
}
}