Master Linked List Coding Questions (2026)

Learn Basic Linked List Coding Questions with simple explanations and beginner-friendly code examples. Perfect for students and interview preparation.

Basic Linked List Coding Questions are designed to help beginners master one of the most fundamental data structures in programming. A linked list is a collection of nodes where each node contains data and a reference (or pointer) to the next node in the sequence. Unlike arrays, linked lists allow dynamic memory allocation, making them highly useful for scenarios where the size of the data can change frequently.

These coding questions cover all the essential operations of a linked list, such as:

• Creating a linked list: Understanding how to initialize nodes and link them together.
• Insertion: Adding new nodes at the beginning, middle, or end of the list.
• Deletion: Removing nodes safely without breaking the chain.
• Traversal: Accessing each node to perform operations like printing data or finding elements.
• Searching: Locating a specific value within the list.
• Counting nodes: Determining the size of the list dynamically.

Practicing these questions builds a strong foundation in pointers, memory management, and dynamic data structures, which are crucial for coding interviews, competitive programming, and real-world software development.

This guide focuses on beginner-friendly explanations and clean code examples, making it easy to follow step by step. By solving these questions, you not only learn the mechanics of linked lists but also improve problem-solving skills, logical thinking, and confidence in handling more complex data structures in the future.

Whether you are a student, a beginner programmer, or preparing for interviews, mastering basic linked list coding questions is the first step toward becoming a proficient programmer.

Creation & Traversal

1. Create a singly linked list
2. Traverse and print a linked list
3. Count number of nodes in a linked list
4. Search an element in a linked list
5. Find length of linked list (iterative & recursive)

Insertion

6. Insert at head
7. Insert at tail
8. Insert at a given position
9. Insert after a given value
10. Insert before a given value
11. Insert in the middle of linked list

Deletion

12. Delete head node
13. Delete tail node
14. Delete node at a given position
15. Delete node by value
16. Delete entire linked list

Basic Pointer Logic

17. Find middle of linked list
18. Find Nth node from beginning
19. Find Nth node from end
20. Check if linked list is empty

Reversal

21. Reverse linked list (iterative)
22. Reverse linked list (recursive)
23. Reverse first K nodes

Two Pointer / Slow-Fast

24. Detect loop in linked list
25. Find starting point of loop
26. Remove loop from linked list

Comparison & Checking

27. Check if linked list is palindrome
28. Compare two linked lists
29. Check if two linked lists intersect

Sorting & Merging

30. Merge two sorted linked lists
31. Sort a linked list
32. Remove duplicates from sorted list
33. Remove duplicates from unsorted list

Interview-Famous Basics

34. Add two numbers represented by linked lists
35. Rotate linked list
36. Pairwise swap nodes
37. Delete alternate nodes
38. Move last node to front

MUST-DO (Very Important)

If you do only these 10, you’re good for interviews:

1. Insert at head
2. Insert at tail
3. Insert at position
4. Delete at position
5. Reverse linked list
6. Find middle
7. Nth node from end
8. Detect loop
9. Remove duplicates
10. Merge two sorted lists

Creation & Traversal based Linked List Coding Questions

1. Create a singly linked list

#include 
using namespace std;

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

    // Constructor
    Node(int data) {
        this->data = data;
        this->next = NULL;
    }
};

// Insert at Tail
void insertAtTail(Node* &head, int data) {
    Node* newNode = new Node(data);

    // If list is empty
    if (head == NULL) {
        head = newNode;
        return;
    }

    Node* temp = head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    temp->next = newNode;
}

// Display Linked List
void printList(Node* head) {
    Node* temp = head;
    while (temp != NULL) {
        cout << temp->data << " -> ";
        temp = temp->next;
    }
    cout << "NULL";
}

// Main function
int main() {
    Node* head = NULL;

    insertAtTail(head, 10);
    insertAtTail(head, 20);
    insertAtTail(head, 30);
    insertAtTail(head, 40);

    cout << "Singly Linked List: ";
    printList(head);

    return 0;
}

2.Traverse and Print a Linked List in C++

#include 
using namespace std;

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

    Node(int data) {
        this->data = data;
        this->next = NULL;
    }
};

// Traverse and print function
void traverseAndPrint(Node* head) {
    Node* temp = head;

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

// Main function
int main() {
    // Creating linked list manually
    Node* head = new Node(10);
    head->next = new Node(20);
    head->next->next = new Node(30);

    cout << "Linked List: ";
    traverseAndPrint(head);

    return 0;
}

3.Count Number of Nodes in a Linked List (C++)

#include 
using namespace std;

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

    Node(int data) {
        this->data = data;
        this->next = NULL;
    }
};

// Function to count nodes
int countNodes(Node* head) {
    int count = 0;
    Node* temp = head;

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

// Main function
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);

    cout << "Number of nodes: " << countNodes(head);

    return 0;
}

4.Search an element in a linked list

#include 
using namespace std;

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

    Node(int data) {
        this->data = data;
        this->next = NULL;
    }
};

// Search function
bool searchElement(Node* head, int key) {
    Node* temp = head;

    while (temp != NULL) {
        if (temp->data == key) {
            return true;   // Element found
        }
        temp = temp->next;
    }
    return false;          // Element not found
}

// Main function
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 key = 30;

    if (searchElement(head, key))
        cout << "Element found in the linked list";
    else
        cout << "Element not found in the linked list";

    return 0;
}

Recursive Search

bool searchRecursive(Node* head, int key) {
    if (head == NULL)
        return false;

    if (head->data == key)
        return true;

    return searchRecursive(head->next, key);
}

5.Find length of linked list (iterative & recursive)

#include 
using namespace std;

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

    Node(int data) {
        this->data = data;
        this->next = NULL;
    }
};

int lengthIterative(Node* head) {
    int count = 0;
    Node* temp = head;

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

Recursive Method

int lengthRecursive(Node* head) {
    if (head == NULL)
        return 0;

    return 1 + lengthRecursive(head->next);
}

Insertion based Linked List Coding Questions

1.Insert at head

#include 
using namespace std;

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

    Node(int data) {
        this->data = data;
        this->next = NULL;
    }
};

// Insert at head function
void insertAtHead(Node* &head, int data) {
    Node* newNode = new Node(data); // Step 1: create new node
    newNode->next = head;           // Step 2: point to current head
    head = newNode;                 // Step 3: update head
}

// Print linked list
void printList(Node* head) {
    Node* temp = head;
    while (temp != NULL) {
        cout << temp->data << " -> ";
        temp = temp->next;
    }
    cout << "NULL" << endl;
}

// Main function
int main() {
    Node* head = NULL; // empty linked list

    insertAtHead(head, 10);
    insertAtHead(head, 20);
    insertAtHead(head, 30);

    cout << "Linked List after inserting at head: ";
    printList(head);

    return 0;
}

2.Insert at Tail in a Linked List

#include 
using namespace std;

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

    Node(int data) {
        this->data = data;
        this->next = NULL;
    }
};

// Insert at tail function
void insertAtTail(Node* &head, int data) {
    Node* newNode = new Node(data);

    if (head == NULL) { // If list is empty
        head = newNode;
        return;
    }

    Node* temp = head;
    while (temp->next != NULL) { // Traverse to last node
        temp = temp->next;
    }
    temp->next = newNode; // Link last node to new node
}

// Print linked list
void printList(Node* head) {
    Node* temp = head;
    while (temp != NULL) {
        cout << temp->data << " -> ";
        temp = temp->next;
    }
    cout << "NULL" << endl;
}

// Main function
int main() {
    Node* head = NULL; // empty list

    insertAtTail(head, 10);
    insertAtTail(head, 20);
    insertAtTail(head, 30);

    cout << "Linked List after inserting at tail: ";
    printList(head);

    return 0;
}

3.Insert node at a given position

#include 
using namespace std;

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

// Delete node at given position (0-based index)
Node* deleteAtPosition(Node* head, int position) {
    if (head == NULL)
        return head;

    // Case 1: Delete head node
    if (position == 0) {
        Node* temp = head;
        head = head->next;
        delete temp;
        return head;
    }

    Node* current = head;

    // Traverse to (position - 1)
    for (int i = 0; i < position - 1 && current->next != NULL; i++) {
        current = current->next;
    }

    // If position is valid
    if (current->next != NULL) {
        Node* temp = current->next;
        current->next = temp->next;
        delete temp;
    }

    return head;
}

4.Delete Node by Value

Node* deleteByValue(Node* head, int value) {
    if (head == NULL)
        return head;

    // Case 1: Value at head
    if (head->data == value) {
        Node* temp = head;
        head = head->next;
        delete temp;
        return head;
    }

    Node* current = head;

    // Search for the value
    while (current->next != NULL && current->next->data != value) {
        current = current->next;
    }

    // If value found
    if (current->next != NULL) {
        Node* temp = current->next;
        current->next = temp->next;
        delete temp;
    }

    return head;
}

5.Delete Entire Linked List

void deleteEntireList(Node*& head) {
    Node* current = head;
    while (current != NULL) {
        Node* temp = current;
        current = current->next;
        delete temp;
    }
    head = NULL;
}

FAQ : Linked List Coding Questions

1. What is a linked list in simple words?

A linked list is a data structure where elements are stored in separate nodes, and each node points to the next one instead of being stored in continuous memory.

2. Why should I learn linked lists?

Linked lists help you understand dynamic memory, pointers, and real-world data structure concepts that are important for coding interviews and advanced programming.

3. What are the basic operations in a linked list?

The basic operations include insertion, deletion, traversal, searching, and counting nodes in the list.

4. Is a linked list better than an array?

It depends on the use case. Linked lists are better for frequent insertions and deletions, while arrays are faster for accessing elements by index.

5. What is a node in a linked list?

A node is a single unit of a linked list that stores data and a pointer (or reference) to the next node.

6. What is the difference between singly and doubly linked lists?

A singly linked list points only to the next node, while a doubly linked list points to both the previous and the next nodes.

7. Are linked list coding questions difficult for beginners?

No, basic linked list questions are easy if you understand pointers and practice step by step with simple examples.

8. Which language is best for learning linked lists?

C and C++ are commonly used because they clearly show pointer concepts, but Java and Python are also good options.

9. What are the most common linked list interview questions?

Common questions include reversing a linked list, finding the middle node, detecting a loop, and deleting a node at a given position.

10. How can I avoid mistakes while coding linked lists?

Always check for null pointers, handle edge cases like empty lists, and test your code with small inputs.

11. How much practice is needed to master linked lists?

With regular practice for a few days and solving basic problems, you can become comfortable with linked list concepts.

12. Are linked lists still used in real projects?

Yes, linked lists are used internally in operating systems, memory management, and many software libraries.

Read More : FPGA Interview Questions & Answers

Raj Kumar

Mr. Raj Kumar is a highly experienced Technical Content Engineer with 7 years of dedicated expertise in the intricate field of embedded systems. At Embedded Prep, Raj is at the forefront of creating and curating high-quality technical content designed to educate and empower aspiring and seasoned professionals in the embedded domain.

Throughout his career, Raj has honed a unique skill set that bridges the gap between deep technical understanding and effective communication. His work encompasses a wide range of educational materials, including in-depth tutorials, practical guides, course modules, and insightful articles focused on embedded hardware and software solutions. He possesses a strong grasp of embedded architectures, microcontrollers, real-time operating systems (RTOS), firmware development, and various communication protocols relevant to the embedded industry.

Raj is adept at collaborating closely with subject matter experts, engineers, and instructional designers to ensure the accuracy, completeness, and pedagogical effectiveness of the content. His meticulous attention to detail and commitment to clarity are instrumental in transforming complex embedded concepts into easily digestible and engaging learning experiences. At Embedded Prep, he plays a crucial role in building a robust knowledge base that helps learners master the complexities of embedded technologies.

embeddedprep.com/