Program to Implement Singly Linked List in C++ Using Class

A singly linked list is a linear data structure where each element (node) points to the next element in the sequence. It consists of nodes, with each node having two components: a data part to store the value and a next pointer part to store the address of the next node.

Traditionally, we represent the linked list node as struct or POD class, where it only contains the data field and next pointer. However, C++ classes allow you to encapsulate all the related functionality into a single type providing better modularity, data abstraction, and the ability to maintain and extend code more effectively.

Representation of Singly Linked List as a Class

To represent a singly linked list as a class, we need to first define a Node type that represents a single node.

class Node {
    int data;
    Node* next;
}

We then define the class that contains the pointer to the head of the linked list as data member and all basic operation functions. For now, we will only include the insertAtHead() and print() function for simplicity.

class LinkedList {
      Node* head;
    public:
      void insertAtHead(){ ... }
      void print() { ... }
}

We can add more functions such as accessing element at particular position, search and delete operations, etc. according to our requirements.

To know how to insert element at head and print linked list, refer to the following articles:

• Insertion in Linked List
• Traversal of Singly Linked List

Implementing data structures like linked lists is fundamental for developing efficient applications.

Implementation

// C++ program to implement singly linked list using a class
#include <iostream>
using namespace std;

// Node class to represent a node of the linked list.
class Node {
  public:
    int data;
    Node *next;

    // Default constructor
    Node() {
        data = 0;
        next = NULL;
    }

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

// Linked list class to implement a singly linked list
class Linkedlist {
    Node *head;

  public:
    // Default constructor
    Linkedlist() {
        head = NULL;
    }

    // Function to insert a node at the start of the
    // linked list
    void insertAtHead(int data) {

        // Create the new Node
        Node *newNode = new Node(data);

        // Assign to head of the list is empty
        if (head == NULL) {
            head = newNode;
            return;
        }

        // Insert the newly created linked list at the head
        newNode->next = this->head;
        this->head = newNode;
    }

    // Function to print the linked list.
    void print() {
        Node *temp = head;

        // Check for empty list
        if (head == NULL) {
            cout << "List empty" << endl;
            return;
        }

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

int main() {

    // Creating a LinkedList object
    Linkedlist list;

    // Inserting nodes
    list.insertAtHead(4);
    list.insertAtHead(3);
    list.insertAtHead(2);
    list.insertAtHead(1);

    cout << "Elements of the list are: ";

    // Print the list
    list.print();
    cout << endl;

    return 0;
}

Elements of the list are: 1 2 3 4 

Time Complexity: O(N)
Auxiliary Space: O(N)

Conclusion

A linked list that is implemented as a class have following advantages:

1. Encapsulation hides internal details, protecting the list's structure and ensuring only controlled access.
2. Organizes all related operations (insertion, deletion, display) within the class, making the code more readable and maintainable.
3. Supports extending functionality through derived classes, promoting code reuse.

In C++, STL contains are all implemented using classes.