How to Implement Iterator for a Doubly Linked List in C++? Last Updated : 08 Jul, 2024 Comments Improve Suggest changes Like Article Like Report 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 ListTo 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 ListThe 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; } Output10 20 30 Time Complexity: O(n), where n is the number of elements in the list. Auxilary Space: O(1) Comment More infoAdvertise with us Next Article How to Implement Iterator for a Doubly Linked List in C++? G gauravggeeksforgeeks Follow Improve Article Tags : C++ Programs C++ cpp-iterator CPP Examples Practice Tags : CPP Similar Reads C++ Program For Inserting A Node In A Linked List Inserting a node into a linked list can be done in several ways, depending on where we want to insert the new node. Here, we'll cover four common scenarios: inserting at the front of the list, after a given node, at a specific position, and at the end of the listTable of ContentInsert a Node at the 9 min read How to Access First Element in a Vector Using Iterator in C++? In C++, vectors are containers similar to arrays but unlike arrays, vectors can resize themselves during the runtime. These vectors provide iterators to access their elements. In this article, we will learn how to access the first element in a vector using an iterator in C++. Example Input:myVector 2 min read C++ Program For Insertion Sort In A Singly Linked List We have discussed Insertion Sort for arrays. In this article we are going to discuss Insertion Sort for linked list. Below is a simple insertion sort algorithm for a linked list. 1) Create an empty sorted (or result) list. 2) Traverse the given list, do following for every node. ......a) Insert curr 5 min read How to Traverse a List with const_iterator in C++? In C++, a list is a container used to store data in non-contiguous memory locations. It also provides a constant iterator that provides the constant reference to its elements. In this article, we will discuss how to traverse a list with const_iterator in C++. Example Input: myList = {10,20,30,40,50} 2 min read C++ Program For Reversing A Doubly Linked List Given a Doubly Linked List, the task is to reverse the given Doubly Linked List. See below diagrams for example. (a) Original Doubly Linked List (b) Reversed Doubly Linked List Here is a simple method for reversing a Doubly Linked List. All we need to do is swap prev and next pointers for all nodes 5 min read C++ Program For Deleting A Node In A Doubly Linked List Pre-requisite: Doubly Link List Set 1| Introduction and Insertion Write a function to delete a given node in a doubly-linked list. Original Doubly Linked List Recommended: Please solve it on "PRACTICE" first, before moving on to the solution. Approach: The deletion of a node in a doubly-linked list 4 min read Menu Driven Program to implement all the operations of Doubly Circular Linked List Circular Doubly Linked List has properties of both Doubly Linked List and Circular Linked List in which two consecutive elements are linked or connected by previous and next pointer and the last node points to the first node by next pointer and also the first node points to the last node by the prev 15+ min read C++ Program For Merge Sort For Doubly Linked List Given a doubly linked list, write a function to sort the doubly linked list in increasing order using merge sort.For example, the following doubly linked list should be changed to 24810 Recommended: Please solve it on "PRACTICE" first, before moving on to the solution. Merge sort for singly linked l 3 min read C++ Program For Moving Last Element To Front Of A Given Linked List Write a function that moves the last element to the front in a given Singly Linked List. For example, if the given Linked List is 1->2->3->4->5, then the function should change the list to 5->1->2->3->4. Algorithm: Traverse the list till the last node. Use two pointers: one t 3 min read 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 t 3 min read Like