Introduction to Linked List & Its Operations

1. Introduction

2. What is a Linked List?

3. Why Use a Linked List?

4. Types of Linked List

5. Basic Structure of a Linked List Node

6. Operations on Linked List

   • Insert at Start

   • Insert After a Specific Node

   • Insert at End

   • Display Linked List

7. Real-World Use Cases

8. Advantages and Limitations

9. Conclusion

Lesson 03: Dynamic vs. Static Data Structures, Pointers, and Structures

1. Introduction

In programming, data often changes dynamically. Traditional arrays have fixed sizes, making them inefficient when frequent insertion or deletion is required.
To overcome these limitations, Linked Lists are used. They are one of the most fundamental dynamic data structures in computer science.

2. What is a Linked List?

Definition

A Linked List is a linear dynamic data structure where elements (called nodes) are stored in non-contiguous memory locations. Each node contains:

• Data

• A pointer (link) to the next node

3. Why Use a Linked List?

Importance of Linked List

• Dynamic size (can grow or shrink)

• Efficient insertion and deletion

• No memory wastage

• Better memory utilization compared to arrays

Real-World Analogy

A linked list is like a train, where each coach knows the address of the next coach.

4. Types of Linked List

• Singly Linked List

• Doubly Linked List

• Circular Linked List

📌 In this blog, we focus on a Singly Linked List.

Array Vs. LinkedList

-> When to Use an Array

• When fast random access is required

• When the data size is fixed

• When memory efficiency is critical

Example Use Case:
Storing marks of students where the total number of students is fixed.

-> When to Use a Linked List

• When frequent insertion/deletion is required

• When the data size is unknown or changes dynamically

• When memory reallocation overhead must be avoided

Example Use Case:
Music playlist where songs are added or removed dynamically.

5. Basic Structure of a Linked List Node

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

📌 Each node stores data and a pointer to the next node.

6. Operations on Linked List

6.1 Insert at Start of Linked List

Definition

This operation inserts a new node at the beginning of the linked list.

Use Case

Adding a new task at the top of a task list.

C++ Code

#include <iostream>
using namespace std;

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

void insertAtStart(Node*& head, int value) {
    Node* newNode = new Node();
    newNode->data = value;
    newNode->next = head;
    head = newNode;
}

int main() {
    Node* head = nullptr;
    insertAtStart(head, 10);
    insertAtStart(head, 20);
    insertAtStart(head, 30);

    Node* temp = head;
    while (temp != nullptr) {
        cout << temp->data << " ";
        temp = temp->next;
    }
    return 0;
}

void insertAfter(Node* prevNode, int value) {
    if (prevNode == nullptr)
        return;

    Node* newNode = new Node();
    newNode->data = value;
    newNode->next = prevNode->next;
    prevNode->next = newNode;
}

📌 The previous node must exist before insertion.

6.3 Insert at End of Linked List

Definition

This operation inserts a new node at the end of the linked list.

Use Case

Adding a new message at the end of a chat list.

C++ Code

void insertAtEnd(Node*& head, int value) {
    Node* newNode = new Node();
    newNode->data = value;
    newNode->next = nullptr;

    if (head == nullptr) {
        head = newNode;
        return;
    }

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

    temp->next = newNode;
}

6.4 Display Linked List

Definition

Display operation prints all elements of the linked list from start to end.

Use Case

Displaying all items in a shopping cart.

C++ Code

void display(Node* head) {
    Node* temp = head;
    while (temp != nullptr) {
        cout << temp->data << " ";
        temp = temp->next;
    }
}

7. Real-World Use Cases of Linked List

• Music playlist management

• Browser navigation (back/forward)

• Dynamic memory allocation

• Operating system process management

• Undo/Redo functionality

8. Advantages and Limitations

Advantages

• Dynamic size

• Efficient insertion and deletion

• No need for contiguous memory

Limitations

• Extra memory for pointers

• No direct access like arrays

• Traversal is slower

9. Conclusion

A Linked List is a powerful dynamic data structure that allows flexible memory usage and efficient insertion operations. Understanding basic operations such as insert at start, insert after a specific node, insert at end, and display is essential for mastering advanced data structures like stacks, queues, trees, and graphs.

Linked lists form the backbone of many real-world software systems and are a must-learn topic in Data Structures using C++.

Tech Interview Questions:

What is a Linked List in C++

A linked list is a dynamic data structure in C++ where elements (nodes) are connected using pointers. Each node contains data and a reference to the next node.

How is a linked list different from an array?

Arrays store elements in contiguous memory locations and provide fast access, while linked lists store elements in non-contiguous memory and allow efficient insertion and deletion.

What are the main operations of a linked list?

The main operations of a linked list include insertion at the beginning, insertion at the end, insertion after a specific node, deletion, and traversal (display).

Why are linked lists called dynamic data structures?

Linked lists are called dynamic because memory is allocated at runtime, allowing the list to grow or shrink as needed.

Is a linked list better than an array?

Neither is universally better. Arrays are better for fast access, while linked lists are better for dynamic insertion and deletion.

Are you interested in developing mobile application development skills? You may visit the link below:
https://onlineskilllab.com/2025/11/18/how-to-build-a-complete-flutter-authentication-system-with-firebase-login-signup-reset-password-dashboard/

If you are learning and enjoying, subscribe to our blog for daily updates.