How to Implement Iterator for a Doubly Linked List in C++?

Last Updated : 08 Jul, 2024

In C++, iterators are used to access elements of a container sequentially without exposing the underlying representation. When working with data structures like a doubly linked list, implementing an iterator can greatly enhance the usability and efficiency of the list as it allows users to traverse it easily. In this article, we will learn how to implement an iterator for a doubly linked list in C++.

Implementation of Iterator for a Doubly Linked List

To implement an iterator for a Doubly Linked List in C++, we can create a separate DoublyLinkedListIterator class that operates in conjunction with the DoublyLinkedList class. This iterator class allows us to traverse the list, dereference to access data, increment to move to the next node, decrement to move to the previous node, and compare for equality or inequality to check if two iterators are the same or different. By defining begin() and end() functions in the DoublyLinkedList class, we can obtain iterators pointing to the first element and one past the last element, respectively.

Approach:

First, define the node structure to represent each node in the doubly linked list.
Create the doubly linked list class that implements methods to add and remove nodes from the list.
Then, define the iterator class that provide operators for dereferencing, incrementing, and comparing iterators.
Finally, integrate the iterator with the list to ensure that the doubly linked list class can return iterators pointing to the beginning and end of the list.

C++ Program to Implement Iterator for a Doubly Linked List

The below example demonstrates how we can implement an iterator for a doubly linked list in C++.

C++

// C++ program to implement iterator for doubly linked list

#include <iostream>
using namespace std;

// Node structure for doubly linked list
struct Node {
    int data;
    Node* prev;
    Node* next;

    // Constructor to initialize node with a value
    Node(int value)
        : data(value)
        , prev(nullptr)
        , next(nullptr)
    {
    }
};

// Iterator class for doubly linked list
class DoublyLinkedListIterator {
private:
    Node* current; // Current node pointer

public:
    // Constructor to initialize iterator with a node
    DoublyLinkedListIterator(Node* node)
        : current(node)
    {
    }

    // Dereference operator to return reference to data
    int& operator*() { return current->data; }

    // Prefix increment operator to move to next node
    DoublyLinkedListIterator& operator++()
    {
        current = current->next;
        return *this;
    }

    // Prefix decrement operator to move to previous node
    DoublyLinkedListIterator& operator--()
    {
        current = current->prev;
        return *this;
    }

    // Inequality operator to compare iterators
    bool
    operator!=(const DoublyLinkedListIterator& other) const
    {
        return current != other.current;
    }

    // Equality operator to compare iterators
    bool
    operator==(const DoublyLinkedListIterator& other) const
    {
        return current == other.current;
    }
};

// Doubly linked list class
class DoublyLinkedList {
private:
    // Pointer to head of the list
    Node* head;
    // Pointer to tail of the list
    Node* tail;

public:
    // Constructor to initialize an empty list
    DoublyLinkedList()
        : head(nullptr)
        , tail(nullptr)
    {
    }

    // Function to append a new node with given value to the
    // list
    void append(int value)
    {
        // Create a new node
        Node* newNode = new Node(value);
        // If list is empty, set head and tail
        // to new node
        if (!head) {
            head = tail = newNode;
        }
        // Otherwise, append node to the end of the
        // list
        else {
            tail->next = newNode;
            newNode->prev = tail;
            tail = newNode;
        }
    }

    // Function to return iterator to the beginning of the
    // list
    DoublyLinkedListIterator begin()
    {
        return DoublyLinkedListIterator(head);
    }

    // Function to return iterator to the end of the list
    // (nullptr)
    DoublyLinkedListIterator end()
    {
        return DoublyLinkedListIterator(nullptr);
    }
};

int main()
{
    // Create a doubly linked list
    DoublyLinkedList list;

    // Append elements to the list
    list.append(10);
    list.append(20);
    list.append(30);

    // Iterate through the list using iterators and print
    // elements
    for (DoublyLinkedListIterator it = list.begin();
         it != list.end(); ++it) {
        cout << *it << " ";
    }
    cout << endl;

    return 0;
}

Output

10 20 30

Time Complexity: O(n), where n is the number of elements in the list.
Auxilary Space: O(1)