Tag: linked list interview questions

  • 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

    1. Insert at head
    2. Insert at tail
    3. Insert at a given position
    4. Insert after a given value
    5. Insert before a given value
    6. Insert in the middle of linked list

    Deletion

    1. Delete head node
    2. Delete tail node
    3. Delete node at a given position
    4. Delete node by value
    5. Delete entire linked list

    Basic Pointer Logic

    1. Find middle of linked list
    2. Find Nth node from beginning
    3. Find Nth node from end
    4. Check if linked list is empty

    Reversal

    1. Reverse linked list (iterative)
    2. Reverse linked list (recursive)
    3. Reverse first K nodes

    Two Pointer / Slow-Fast

    1. Detect loop in linked list
    2. Find starting point of loop
    3. Remove loop from linked list

    Comparison & Checking

    1. Check if linked list is palindrome
    2. Compare two linked lists
    3. Check if two linked lists intersect

    Sorting & Merging

    1. Merge two sorted linked lists
    2. Sort a linked list
    3. Remove duplicates from sorted list
    4. Remove duplicates from unsorted list

    Interview-Famous Basics

    1. Add two numbers represented by linked lists
    2. Rotate linked list
    3. Pairwise swap nodes
    4. Delete alternate nodes
    5. 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
11.Add Two Numbers in a Linked List

    Creation & Traversal based Linked List Coding Questions

    1. Create a singly linked list

    #include <iostream>
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 <iostream>
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 <iostream>
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 <iostream>
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 <iostream>
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 <iostream>
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 <iostream>
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 <iostream>
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

  • Master Doubly Linked List in Data Structures (With Examples) 2026

    Introduction to Doubly Linked List

    When you’re learning data structures, you’ll often hear about Linked Lists. A Doubly Linked List (DLL) is a powerful and flexible variation of the basic Singly Linked List that allows you to traverse in both directions — forward and backward.

    In this beginner-friendly article, we’ll explore:

    • What is a Doubly Linked List?
    • How it works (with diagrams)
    • Real-world uses
    • Advantages over singly linked list
    • Basic operations (insertion, deletion, traversal)
    • Code example in C/C++

    🚀 Whether you’re preparing for coding interviews or improving your DSA skills, understanding doubly linked lists is a must!

    What is a Doubly Linked List?

    A Doubly Linked List is a type of linear data structure made up of nodes, where each node contains:

    • Data (the actual value)
    • Pointer to the next node
    • Pointer to the previous node

    ⚙️ Node Structure of Doubly Linked List:

    +-------+----------+----------+
| prev  |   data   |   next   |
+-------+----------+----------+

    Each node is connected to its previous and next node, unlike a singly linked list, which only has a next pointer.

    Visual Representation of Doubly Linked List

    Let’s say we have 3 nodes with data: 10, 20, and 30.

    NULL <- [10] <-> [20] <-> [30] -> NULL

    Here:

    • Node 10’s prev is NULL
    • Node 20’s prev points to 10 and next to 30
    • Node 30’s next is NULL

    Basic Operations on Doubly Linked List

    1. Insertion

    • At the beginning
    • At the end
    • At a specific position

    2. Deletion

    • From the beginning
    • From the end
    • Specific node

    3. Traversal

    • Forward traversal (left to right)
    • Backward traversal (right to left)

    C Code Example: Basic DLL Operations

    #include <stdio.h>
#include <stdlib.h>

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

Node* head = NULL;

// Insert at end
void insertEnd(int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;
    newNode->next = NULL;

    if (head == NULL) {
        newNode->prev = NULL;
        head = newNode;
        return;
    }

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

    temp->next = newNode;
    newNode->prev = temp;
}

// Display forward
void displayForward() {
    Node* temp = head;
    printf("DLL (forward): ");
    while (temp != NULL) {
        printf("%d <-> ", temp->data);
        temp = temp->next;
    }
    printf("NULL\n");
}

// Display backward
void displayBackward() {
    Node* temp = head;
    if (!temp) return;
    
    // Go to last node
    while (temp->next != NULL)
        temp = temp->next;

    printf("DLL (backward): ");
    while (temp != NULL) {
        printf("%d <-> ", temp->data);
        temp = temp->prev;
    }
    printf("NULL\n");
}

int main() {
    insertEnd(10);
    insertEnd(20);
    insertEnd(30);
    
    displayForward();
    displayBackward();
    return 0;
}

    Advantages of Doubly Linked List

    • Two-way traversal: You can navigate forward and backward.
    • Easier deletion: You can delete a node without needing the previous node pointer.
    • More flexible: Especially useful in complex data structures like Deques, Undo/Redo systems, Music Playlists, etc.

    Disadvantages of Doubly Linked List

    • More memory: Each node requires extra space for the prev pointer.
    • More complex: Handling pointers can be error-prone for beginners.

    Real-Life Applications of Doubly Linked List

    • Web browsers (backward and forward navigation)
    • Music playlist apps
    • Text editors (undo/redo operations)
    • Task managers (circular doubly linked lists for round-robin)

    Conclusion DLL

    Doubly Linked List
    Master Doubly Linked List in Data Structures (With Examples) 2025

    The Doubly Linked List is an essential topic in Data Structures and Algorithms (DSA). It offers a better way to manage dynamic data, especially when two-way traversal is needed. Though slightly more complex than a singly linked list, the benefits are powerful.

    Whether you’re preparing for a coding interview, building a system-level application, or just learning C programming, mastering DLLs will give you a strong foundation in memory management and pointer logic.

    FAQs of Doubly Linked List

    Q1: Is doubly linked list faster than singly linked list?
    Ans: DLL allows backward traversal and easier deletion, but it uses more memory. It’s more flexible, not necessarily faster.

    Q2: Where is DLL used in real life?
    Ans: Browser history, playlist navigation, undo/redo features, and memory management systems.

    Q3: What is the main drawback of doubly linked list?
    Ans: It uses extra memory due to the additional prev pointer and increases code complexity.

    Q4: How is a doubly linked list different from a circular doubly linked list?
    Ans: In a doubly linked list, the last node’s next pointer is NULL, whereas in a circular doubly linked list, the last node’s next points back to the head, forming a circle.

    Q5: Can a doubly linked list be empty?
    Ans: Yes, initially a doubly linked list can be empty with head pointing to NULL.

    Q6: How do you insert a node at the beginning of a doubly linked list?
    Ans: Create a new node, point its next to the current head, set the head’s prev to the new node, and then update head to the new node.

    Q7: What happens when you delete the last node in a doubly linked list?
    Ans: The second last node’s next pointer is set to NULL, and the last node is freed from memory.

    Q8: Is it possible to implement a stack using a doubly linked list?
    Ans: Yes, a doubly linked list can be used to implement a stack with push and pop operations.

    Q9: How does traversal in a doubly linked list work?
    Ans: You can traverse forward from head to NULL using next pointers or backward from the last node to head using prev pointers.

    Q10: What are the memory requirements for a doubly linked list node?
    Ans: Each node stores data plus two pointers (prev and next), so it uses more memory compared to a singly linked list node, which stores only one pointer.

    Q11: Can doubly linked lists have cycles? How to detect them?
    Ans: Yes, cycles can exist if nodes point back to earlier nodes. Cycle detection algorithms like Floyd’s Cycle-Finding Algorithm (tortoise and hare) can detect cycles.

    Q12: Are doubly linked lists used in databases?
    Ans: Yes, doubly linked lists are used to implement certain data structures like LRU caches, which are common in databases and operating systems.

    Q13: How do you reverse a doubly linked list?
    Ans: Swap the prev and next pointers for each node and update the head to the last node.

    You can also Visit other tutorials of Embedded Prep