Single Linked List in Data Structure with Code and Use Cases

Single Linked List in Data Structure with Code and Use Cases

• 

  Sonal Rana / 4 day ago
• 11
• 13 min read

This article explains what a single linked list is, its structure, how it works, code examples, real-world use cases, and frequently asked questions, all written in a beginner-friendly way to help you understand it clearly.

1. Types of Linked Lists

Linked lists are linear data structures where elements are stored in nodes, and each node points to the next one in the sequence. Below are the main types:

• Singly Linked List
  • Structure: Each node contains two parts:
    • Data: Holds the actual value.
    • Next Pointer: Points to the next node in the list.
    The last node’s pointer is set to NULL, indicating the end of the list.
  Copy Code

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

  • Characteristics:
    • Unidirectional Traversal (Only forward).
    • Requires a head pointer to access the list.
    • Efficient in inserting and deleting at the beginning.
  • Use Cases:
    • Implementing stacks
    • Maintaining a history of visited pages (e.g., browser navigation)
    • Simple memory management tools
• Doubly Linked List
  • Structure: Each node contains three parts:
    • Data
    • Prev Pointer: Points to the previous node
    • Next Pointer: Points to the next node
  Copy Code

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

  • Characteristics:
    • Bidirectional Traversal
    • Supports operations in both directions
    • More memory overhead due to extra pointer
  • Use Cases:
    • Browser history (forward and back navigation)
    • Music or media playlists
    • Undo/redo features in software applications
• Circular Linked List
  • Structure: The last node points back to the first node instead of NULL.
    • Can be:
      • Singly Circular Linked List: Last node’s next points to the first.
      • Doubly Circular Linked List: Last node’s next points to the first, and first node’s prev points to the last.
  Copy Code

  // Singly Circular
  struct Node {
      int data;
      struct Node* next;
  };
                  

  • Characteristics:
    • No NULL at the end, circular reference
    • Can start traversal from any node
    • Useful for implementing circular buffers
  • Use Cases:
    • Round-robin scheduling in operating systems
    • Multiplayer board games (rotating turns)
    • Memory management in real-time systems

2. What is a Single Linked List in Data Structure?

A single linked list is a linear data structure where elements are stored in nodes, and each node points to the next one in the sequence. Unlike arrays, elements in a linked list are not stored in contiguous memory locations. This makes insertion and deletion operations more efficient in many scenarios.

Each node in a single linked list typically contains two parts:

• Data – the value or information.
• Pointer (or next) – a reference to the next node in the list.

The list starts with a head pointer that points to the first node. The last node points to null, indicating the end of the list.

Visual Representation:
[10 | next] → [20 | next] → [30 | next] → null

3. Why Learn Single Linked Lists?

If you're enrolled in a Data Structures Course in Noida, you'll quickly learn that linked lists are foundational. Here's why:

• They teach you how memory management works under the hood.
• They provide deeper insight into how dynamic data storage works.
• They are used to build more complex structures like stacks, queues, and graphs.
• They help solve real-time problems like scheduling, memory allocation, and implementing undo features in editors.

4. Operations on Single Linked List

Here are the common operations you can perform on a single linked list:

• Insertion
  • At the beginning
  • At the end
  • At a specific position
• Deletion
  • From the beginning
  • From the end
  • By value
• Traversal
  • Visit all nodes to access or display data
• Search
  • Find a specific value in the list

5. Code Implementation in C

Let’s walk through how to implement a single linked list in C:

Node Structure

#include 
#include 

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

Insertion at the Beginning

void insertAtBeginning(struct Node** head, int newData) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = newData;
    newNode->next = *head;
    *head = newNode;
}
    

Insertion at the End

void insertAtEnd(struct Node** head, int newData) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    struct Node* last = *head;

    newNode->data = newData;
    newNode->next = NULL;

    if (*head == NULL) {
        *head = newNode;
        return;
    }

    while (last->next != NULL) {
        last = last->next;
    }

    last->next = newNode;
}
    

Deletion by Value

void deleteNode(struct Node** head, int key) {
    struct Node* temp = *head;
    struct Node* prev = NULL;

    if (temp != NULL && temp->data == key) {
        *head = temp->next;
        free(temp);
        return;
    }

    while (temp != NULL && temp->data != key) {
        prev = temp;
        temp = temp->next;
    }

    if (temp == NULL) return;

    prev->next = temp->next;
    free(temp);
}
    

Traversal

void printList(struct Node* node) {
    while (node != NULL) {
        printf("%d -> ", node->data);
        node = node->next;
    }
    printf("NULL\n");
}
    

Main Function

int main() {
    struct Node* head = NULL;

    insertAtEnd(&head, 10);
    insertAtEnd(&head, 20);
    insertAtBeginning(&head, 5);
    printList(head);

    deleteNode(&head, 10);
    printList(head);

    return 0;
}
    

6. Real-World Use Cases of Single Linked Lists

Understanding the single linked list in data structure is not just about acing coding tests, these structures are used in the real world too.

• Music or Video Playlist Apps
  • Songs or videos are arranged in a sequence. You can move forward one item at a time, just like traversing a linked list.
• Web Browsers (History Navigation)
  • While the doubly linked list is often used for back-and-forth navigation, a simplified version like a single linked list handles the "forward" chain.
• Dynamic Memory Allocation
  • Operating systems use linked lists to manage memory blocks efficiently without needing continuous memory.
• Image Viewer
  • Like playlist apps, images in a gallery can be stored in a linked list, allowing smooth traversal.
• Undo Feature in Applications
  • Many text editors implement undo functionality using linked lists to track the history of changes.

7. Advantages of Single Linked List

• Dynamic size: No need to predefine the size like in arrays.
• Efficient insertion/deletion: Especially at the beginning or middle.
• Low memory overhead: Only stores what's needed.

8. Limitations

• Slow access time: No direct indexing like arrays.
• Extra memory: Each node stores an additional pointer.
• Difficult to reverse: Without extra space or recursive functions.

9. Why Learn from a Data Structures Course in Noida?

If you're serious about mastering data structures, enrolling in a hands-on Data Structures Course in Noida gives you a massive advantage. These courses often include:

• Real-time coding projects
• Expert mentors with industry experience
• Peer discussions and community support
• Focused learning paths with live problem-solving
• Placement assistance in top tech companies

Whether you're learning C, C++, Java, or Python, understanding how a single linked list in data structure works is one of the first building blocks in your coding journey.

10. Common Mistakes in Single Linked List Implementation

• Not Initializing the Head Pointer
  • Mistake:
    Copy Code

    struct Node* head;
                        

    Using head without setting it to NULL first can lead to undefined behavior or crashes.
  • Fix:
    Copy Code

    struct Node* head = NULL;
                        

• Incorrect Memory Allocation
  • Mistake:
    Copy Code

    struct Node* newNode;
    newNode->data = 10;
                        

    Trying to assign data before allocating memory.
  • Fix:
    Copy Code

    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    if (newNode == NULL) {
        printf("Memory not allocated.\n");
        exit(1);
    }
    newNode->data = 10;
                        

• Memory Leaks (Not Freeing Memory)
  • Mistake: Allocating nodes but never using free() to release them.
  • Fix: Always free memory after deleting or finishing with a node:
    Copy Code

    free(temp);
                        

• Incorrect Pointer Manipulation
  • Mistake:
    Copy Code

    current->next = current;
                        

    Wrongly pointing a node to itself, which causes infinite loops.
  • Fix: Double-check pointer assignments. After current = current->next, ensure proper termination conditions.
• Losing Track of the Head Node
  • Mistake: Reassigning head during traversal:
    Copy Code

    head = head->next; // Destroys original head
                        

  • Fix: Use a temporary pointer when traversing:
    Copy Code

    struct Node* temp = head;
                        

• Accessing next of NULL
  • Mistake:
    Copy Code

    while (temp->next->data != x) // Crashes if temp->next is NULL
                        

  • Fix: Always check if temp or temp->next is NULL before accessing:
    Copy Code

    if (temp != NULL && temp->next != NULL)
                        

11. FAQs

• Q1: What is the difference between a single linked list and a doubly linked list?
  • A single linked list allows traversal in one direction, while a doubly linked list lets you move both forward and backward.
• Q2: Is a linked list faster than an array?
  • Linked lists are faster for insertion and deletion but slower for random access.
• Q3: When should I use a single linked list?
  • Use it when you need a dynamic data structure with frequent insertions/deletions, like in queues or stacks.
• Q4: Can I reverse a singly linked list?
  • Yes, but it requires careful pointer manipulation. It can be done iteratively or recursively.
• Q5: Is learning linked lists enough for interviews?
  • No. Linked lists are a starting point. You also need to learn trees, graphs, heaps, and more. A structured Data Structures Course in Noida will cover all these topics.

12. Final Thoughts

The single linked list in data structure is a simple yet powerful concept every developer must master. It lays the foundation for understanding more complex data structures and solving real-world problems efficiently.

Whether you’re a student, job seeker, or coding enthusiast, joining a Data Structures Course in Noida can help you gain deep, practical knowledge. With expert guidance and real coding practice, you’ll be better prepared for technical interviews, competitive programming, and building strong applications.

So, the next time you write code to add, delete, or traverse a linked list, remember, you’re not just learning syntax. You’re building blocks in the digital world.