A Linked List is a dynamic data structure that stores data using interconnected nodes. Each node contains data and a pointer that stores the address of the next node.
Creating a linked list is only the first step. To work with linked lists effectively, programmers perform various operations such as traversal, insertion, deletion, searching, and reversal. These operations allow data to be accessed, modified, and managed efficiently.
Understanding linked list operations is essential because they form the foundation of many advanced data structures and are frequently asked in coding interviews and technical assessments.

Table of Contents

---

Creating a Linked List

Before performing operations, we first need a linked list. Below is the C++ program to create a linked list:

// C++ program to create a linked list
#include iostream
using namespace std;

class Node
{
public:
    int data;
    Node* next;

    Node(int value)
    {
        data = value;
        next = NULL;
    }
};

int main()
{
    Node* first = new Node(10);
    Node* second = new Node(20);
    Node* third = new Node(30);

    first-next = second;
    second-next = third;

    return 0;
}

Linked List Representation:

10 → 20 → 30 → NULL

The above program creates three nodes and connects them to form a linked list.

Traversal in a Linked List

Traversal is the process of visiting every node of a linked list one by one. It is one of the most frequently used operations because many other operations, such as searching and updating data, depend on traversal.
A temporary pointer starts from the head node and moves through the linked list until it reaches NULL. During this process, every node is visited exactly once.
Example:

Before traversal:
10 → 20 → 30 → NULL
Visited nodes:
10
20
30

Below is the C++ program for linked list traversal:

// C++ program to implement linked list traversal
#include iostream
using namespace std;

class Node
{
public:
    int data;
    Node* next;

    Node(int value)
    {
        data = value;
        next = NULL;
    }
};

int main()
{
    Node* head = new Node(10);
    head-next = new Node(20);
    head-next-next = new Node(30);

    Node* temp = head;

    while(temp != NULL)
    {
        cout  temp-data  " ";
        temp = temp-next;
    }

    return 0;
}

Output:

10 20 30

Explanation:

1. A linked list containing three nodes is created.
2. A temporary pointer named temp is initialized with the address of the head node.
3. The while loop continues until temp becomes NULL.
4. Each node’s data is displayed, and the pointer moves to the next node.

Time Complexity: O(n). Every node is visited exactly once.
Space Complexity: O(1). No extra memory is used.

Insertion at the Beginning of a Linked List

Insertion at the beginning adds a new node before the current head node. After insertion, the newly added node becomes the first node of the linked list.
This is one of the fastest insertion operations because only pointer references need to be updated.
Example:

Before Insertion
10 → 20 → 30 → NULL
After Inserting 5
5 → 10 → 20 → 30 → NULL

Below is the C++ program to implement insertion at the beginning of the linked list:

// C++ program to implement insertion
// at the beginning of the linked list
#include iostream
using namespace std;

class Node
{
public:
    int data;
    Node* next;

    Node(int value)
    {
        data = value;
        next = NULL;
    }
};

void display(Node* head)
{
    Node* temp = head;

    while(temp != NULL)
    {
        cout  temp-data  " ";
        temp = temp-next;
    }

    cout  endl;
}

int main()
{
    Node* head = new Node(10);
    head-next = new Node(20);
    head-next-next = new Node(30);

    Node* newNode = new Node(5);

    newNode-next = head;
    head = newNode;

    display(head);

    return 0;
}

Output:

5 10 20 30

Explanation:

1. Create the original linked list: 10 → 20 → 30 → NULL.
2. Create a new node containing the value 5.
3. Connect the new node to the current head: newNode-next = head;
4. Update the head pointer: head = newNode;
5. The new node becomes the first node: 5 → 10 → 20 → 30 → NULL.

Time Complexity: O(1). Only pointer updates are required.
Space Complexity: O(1). No extra memory is used apart from the new node.

Insertion at the End of a Linked List

Insertion at the end adds a new node after the last node of the linked list.
To perform this operation, the list must first be traversed to locate the last node.
Example:

Before Insertion
10 → 20 → 30 → NULL
After Inserting 40
10 → 20 → 30 → 40 → NULL

Below is the C++ program to implement insertion at the end of the linked list:

// C++ program to implement insertion at the 
// end of the linked list
#include iostream
using namespace std;

class Node
{
public:
    int data;
    Node* next;

    Node(int value)
    {
        data = value;
        next = NULL;
    }
};

void display(Node* head)
{
    Node* temp = head;

    while(temp != NULL)
    {
        cout  temp-data  " ";
        temp = temp-next;
    }

    cout  endl;
}

int main()
{
    Node* head = new Node(10);
    head-next = new Node(20);
    head-next-next = new Node(30);

    Node* newNode = new Node(40);

    Node* temp = head;

    while(temp-next != NULL)
    {
        temp = temp-next;
    }

    temp-next = newNode;

    display(head);

    return 0;
}

Output:
10 20 30 40
Explanation:

1. Create the linked list: 10 → 20 → 30 → NULL.
2. Create a new node containing 40.
3. Traverse the list until the last node is reached.
4. Attach the new node after the last node: temp-next = newNode;
5. The linked list becomes: 10 → 20 → 30 → 40 → NULL

Time Complexity: O(n). The entire list may need to be traversed.
Space Complexity: O(1). No additional memory is required.

Deletion at the Beginning of a Linked List

Deletion at the beginning removes the first node from the linked list. After deletion, the second node becomes the new head node.
This operation is very efficient because only the head pointer needs to be updated.
Example:

Before Deletion
10 → 20 → 30 → NULL
After Deletion
20 → 30 → NULL

Below is the C++ program to implement deletion at the beginning of the linked list:

// C++ program to implement deletion at the 
// beginning of linked list
#include iostream
using namespace std;

class Node
{
public:
    int data;
    Node* next;

    Node(int value)
    {
        data = value;
        next = NULL;
    }
};

void display(Node* head)
{
    Node* temp = head;

    while(temp != NULL)
    {
        cout  temp-data  " ";
        temp = temp-next;
    }

    cout  endl;
}

int main()
{
    Node* head = new Node(10);
    head-next = new Node(20);
    head-next-next = new Node(30);

    Node* temp = head;

    head = head-next;

    delete temp;

    display(head);

    return 0;
}

Output:

20 30

Explanation:

1. Create the linked list: 10 → 20 → 30 → NULL
2. Store the address of the first node in a temporary pointer.
3. Move the head pointer to the second node: head = head-next;
4. Delete the old first node: delete temp;
5. The linked list becomes: 20 → 30 → NULL

Time Complexity: O(1). Only the head pointer is updated.
Space Complexity: O(1). No additional memory is required.

Deletion at the End of a Linked List

Deletion at the end removes the last node from the linked list. To perform this operation, the program must first locate the second-last node and then disconnect the last node.
Unlike deletion at the beginning, this operation requires traversal because the last node cannot be accessed directly.
Example:

Before Deletion
10 → 20 → 30 → NULL
After Deletion
10 → 20 → NULL

Below is the C++ program to implement deletion at the end of the linked list:

// C++ program to delete the node at 
// the end of the linked list
#include iostream
using namespace std;

class Node
{
public:
    int data;
    Node* next;

    Node(int value)
    {
        data = value;
        next = NULL;
    }
};

void display(Node* head)
{
    Node* temp = head;

    while(temp != NULL)
    {
        cout  temp-data  " ";
        temp = temp-next;
    }

    cout  endl;
}

int main()
{
    Node* head = new Node(10);
    head-next = new Node(20);
    head-next-next = new Node(30);

    Node* temp = head;

    while(temp-next-next != NULL)
    {
        temp = temp-next;
    }

    delete temp-next;
    temp-next = NULL;

    display(head);

    return 0;
}

Output:

10 20

Explanation:

1. Create the linked list: 10 → 20 → 30 → NULL
2. Traverse the list until the second-last node is found.
3. Delete the last node: delete temp-next;
4. Update the second-last node’s next pointer: temp-next = NULL;
5. The linked list becomes: 10 → 20 → NULL

Time Complexity: O(n). The linked list may need to be traversed completely.
Space Complexity: O(1). No extra memory is required.

Searching in a Linked List

Searching is the process of finding whether a particular element exists in the linked list. The search starts from the head node and continues until the required value is found or the end of the list is reached.
Since linked lists do not support indexing like arrays, every node must be checked sequentially.
Example:

Linked List
10 → 20 → 30 → NULL
Search Element
20

Below is the C++ program to implement search in a linked list:

// C++ program to implement searching in a 
// linked list
#include iostream
using namespace std;

class Node
{
public:
    int data;
    Node* next;

    Node(int value)
    {
        data = value;
        next = NULL;
    }
};

int main()
{
    Node* head = new Node(10);
    head-next = new Node(20);
    head-next-next = new Node(30);

    int key = 20;
    bool found = false;

    Node* temp = head;

    while(temp != NULL)
    {
        if(temp-data == key)
        {
            found = true;
            break;
        }

        temp = temp-next;
    }

    if(found)
        cout  "Element Found";
    else
        cout  "Element Not Found";

    return 0;
}

Output:

Element Found

Explanation:

1. Create the linked list: 10 → 20 → 30 → NULL
2. Store the value to be searched: int key = 20;
3. Traverse the linked list node by node.
4. Compare every node’s value with the target value.
5. Display the result when the element is found.

Time Complexity: O(n). In the worst case, every node must be checked.
Space Complexity: O(1). No extra memory is used.

Finding the Length of a Linked List

Finding the length of a linked list means counting the total number of nodes present in the list.
This operation is useful when performing position-based insertions, deletions, and validations.
Example:

Linked List
10 → 20 → 30 → 40 → NULL

Below is the C++ program to find the length of a linked list:

// C++ program to find the length of 
// a linked list
#include iostream
using namespace std;

class Node
{
public:
    int data;
    Node* next;

    Node(int value)
    {
        data = value;
        next = NULL;
    }
};

int main()
{
    Node* head = new Node(10);
    head-next = new Node(20);
    head-next-next = new Node(30);
    head-next-next-next = new Node(40);

    int count = 0;

    Node* temp = head;

    while(temp != NULL)
    {
        count++;
        temp = temp-next;
    }

    cout  "Length of Linked List = "  count;

    return 0;
}

Output:

Length of Linked List = 4

Explanation:

1. Initialize a counter variable with 0.
2. Traverse the linked list from the head node.
3. Increase the counter for every visited node.
4. Display the final count.

Time Complexity: O(n). Every node must be visited once.
Space Complexity: O(1). No extra memory is required.

Reversing a Linked List

Reversing a linked list changes the direction of all links between nodes. After reversal, the first node becomes the last node and the last node becomes the new head.
This is one of the most frequently asked linked list interview questions because it tests understanding of pointers.
Example:

Before Reversal
10 → 20 → 30 → NULL
After Reversal
30 → 20 → 10 → NULL

Below is the C++ program to reverse a linked list:

// C++ program to reverse a linked list
#include iostream
using namespace std;

class Node
{
public:
    int data;
    Node* next;

    Node(int value)
    {
        data = value;
        next = NULL;
    }
};

void display(Node* head)
{
    Node* temp = head;

    while(temp != NULL)
    {
        cout  temp-data  " ";
        temp = temp-next;
    }

    cout  endl;
}

int main()
{
    Node* head = new Node(10);
    head-next = new Node(20);
    head-next-next = new Node(30);

    Node* prev = NULL;
    Node* current = head;
    Node* nextNode = NULL;

    while(current != NULL)
    {
        nextNode = current-next;
        current-next = prev;

        prev = current;
        current = nextNode;
    }

    head = prev;

    display(head);

    return 0;
}

Output:

30 20 10

Explanation:

1. Create the linked list: 10 → 20 → 30 → NULL.
2. Use three pointers: prev, current, and nextNode.
3. Reverse the direction of every link.
4. Move all pointers one step forward.
5. Update the head pointer: head = prev;
6. The reversed linked list becomes: 30 → 20 → 10 → NULL

Time Complexity: O(n). Every node is visited exactly once.
Space Complexity: O(1). Only a few extra pointers are used.

Conclusion

Linked list operations such as deletion, searching, length calculation, and reversal are essential for managing dynamic data efficiently. These operations help programmers manipulate data structures without requiring contiguous memory allocation.
Understanding these concepts strengthens problem-solving skills, improves pointer handling, and prepares students for coding interviews and advanced DSA topics. Once these operations are mastered, solving complex linked list problems becomes much easier.

Frequently Asked Questions

1. Why is deletion at the end slower than deletion at the beginning?

Deletion at the end requires traversal to find the second-last node, while deletion at the beginning only updates the head pointer.

2. Why does searching take O(n) time?

Linked lists do not support direct indexing, so nodes must be checked one by one.

3. Why is reversing a linked list a popular interview question?

It tests understanding of pointers, node manipulation, and linked list traversal.

4. Can linked lists grow dynamically?

Yes. Nodes can be added and removed during program execution.

5. Which linked list operation is used most frequently?

Traversal is the most commonly used operation because many other operations depend on it.

6. How is linked list length calculated?

The list is traversed and every visited node is counted.