In C++, forward_list container provides the implementation of singly linked list data structure. It stores data in non-contiguous memory where each element points to the next element in the sequence. This makes insertion and deletion faster once the position of the element is known.
Example:
C++ #include <iostream> #include <forward_list> using namespace std; int main() { // Create a forward list with 4 elements forward_list<int> fl = {1, 5, 3, 4}; for (auto i : fl) cout << i << " "; return 0; } Explanation: In the above program, we created a forward list fl and initialized it with the 4 elements {1, 5, 3, 4}.
Syntax
Forward list is defined as std::forward_list class template inside the <forward_list> header file.
forward_list<T> fl;
where,
- T: Data type of elements in the forward list.
- fl: Name assigned to the forward list.
Declaration and Initialization
A forward_list can be declared and initialized in several ways as shown in the below example:
C++ #include <bits/stdc++.h> using namespace std; void printFL(forward_list<int>& fl) { for (auto i : fl) cout << i << " "; cout << '\n'; } int main() { // Creating an empty forward_list forward_list<int> fl1; // Creating a forward_list with // default value forward_list<int> fl2(3, 4); // Creating a forward_list from an // initializer list forward_list<int> fl3 = {1, 5, 3, 4}; printFL(fl2); printFL(fl3); return 0; } Example: In the above program, we are simple initialized forward list in three ways:
- Statement forward_list<int> fl1 creates an empty forward list of integers.
- Statement forward_list<int> fl2(3,4) creates a forward list of size 3 and with each element being 4.
- Statement forward_list<int> fl3 = {1, 5, 3, 4} creates a forward list and initializes with the elements form the initializer list.
Basic Operations
Here are the basic operations we can perform on a forward list:
1. Accessing Elements
Forward list’s elements cannot be accessed using indices like arrays or vectors. We have to go through the list sequentially from the start to the desired position to access it. This can be done by incrementing begin() iterator, but it is better to use next() or advance() function.
However, first element of the list can be easily accessed by front() method.
Example:
C++ #include <bits/stdc++.h> using namespace std; int main() { forward_list<int> fl = {1, 5, 3, 4}; // Access the first element cout << fl.front() << endl; // Access third element auto it = next(fl.begin(), 2); cout << *it; return 0; } Example: In the above program, the first element is printed by using front() method. To access the third element, next() is used to move the iterator two positions from the beginning, and *it is used to dereference the iterator.
2. Inserting Elements
Elements can be inserted in the forward list using insert_after() function. It requires the iterator after which the element is to be inserted. However, fast insertion at the front is supported by push_front() method.
Example:
C++ #include <bits/stdc++.h> using namespace std; int main() { forward_list<int> fl = {5, 4}; // Inserting Element at front fl.push_front(1); // Insert 3 after the second element auto it = fl.begin(); advance(it, 1); fl.insert_after(it, 3); for (auto x: fl) cout << x << " "; return 0; } Explanation: In this program, the first element of the forward_list is inserted at the front using the push_front() function. Then, an iterator is created and moved one position forward using the advance() function. After that, the element 5 is inserted after the second element using the insert_after() function.
3. Updating Elements
The value of existing elements can be changed simply by accessing them and using assignment operator to assign the new value.
Example:
C++ #include <bits/stdc++.h> using namespace std; int main() { forward_list<int> fl = {1, 5, 3, 4}; // Updating first element fl.front() = 111; cout << fl.front() << endl; // Updating third element auto it = next(fl.begin(), 2); *it = 333; cout << *it; return 0; } 4. Finding Element
The forward list does not provide any member function to search for an element, but we can use the find() algorithm to find any given value.
Example:
C++ #include <bits/stdc++.h> using namespace std; int main() { forward_list<int> fl = {1, 5, 3, 4}; // Finding 3 auto it = find(fl.begin(), fl.end(), 3); if (it != fl.end()) cout << *it; else cout << "Element not Found"; return 0; } 5. Traversing
A forward list can be traversed using begin() and end() iterators with a loop, but we can only move forward and not backward.
Example:
C++ #include <bits/stdc++.h> using namespace std; int main() { forward_list<int> fl = {1, 5, 3, 4}; // Traversing using range-based for loop for(auto i : fl) cout << i << " "; cout << endl; return 0; } 6. Deleting Elements
In forward list, we can delete the element at the given position using erase_after() method. This method takes the iterator to one position before the target element. Fast deletion from the front is possible using pop_front() method.
Example:
C++ #include <bits/stdc++.h> using namespace std; int main() { forward_list<int> fl = {1, 5, 3, 4}; // Delete first element fl.pop_front(); // Delete third element auto it = fl.begin(); advance(it, 1); fl.erase_after(it); for (auto x: fl) cout << x << " "; return 0; } Time Complexity
The below table lists the time complexity of the above operations on forward list:
| Operation | Time Complexity |
|---|
| Access first element | O(1) |
| Access nth element | O(n) |
| Insert at front | O(1) |
| Insert after specific position | O(n) |
| Delete first element | O(1) |
| Delete after specific position | O(n) |
| Traversal | O(n) |
Other Common Operations
The following articles demonstrate some other operations that are commonly performed on a forward list container:
Internal Working
A forward list container provides the implementation of a singly linked list data structure. Each element in the list is stored in a node, which consists of two parts: the data and a pointer to the next node. The forward list maintains a pointer to the first node, known as the head, and the rest of the list contains the address of the next element in the sequence. This allows for fast insertion and deletion if the iterator to the element is known beforehand. But it sacrifices the random-access capability.
Forward List vs List
The key difference between a list and a forward list is given below:
- Forward list is a singly linked list with only a pointer to the next element, allowing traversal in one direction.
- List is a doubly linked list with pointers to both the next and previous elements, traversal in both directions.
All Member Functions
Following list cover all the functions of forward list:
Functions | Definition |
|---|
| front() | This function is used to reference the first element of the forward list container. |
|---|
| begin() | This function is used to return an iterator pointing to the first element of the forward list container. |
|---|
| end() | This function is used to return an iterator pointing to the last element of the list container. |
|---|
| cbegin() | Returns a constant iterator pointing to the first element of the forward_list. |
|---|
| cend() | Returns a constant iterator pointing to the past-the-last element of the forward_list. |
|---|
| before_begin() | Returns an iterator that points to the position before the first element of the forward_list. |
|---|
| cbefore_begin() | Returns a constant iterator which points to the position before the first element of the forward_list. |
|---|
| max_size() | Returns the maximum number of elements that can be held by forward_list. |
|---|
| resize() | Changes the size of forward_list. |
|---|
| unique() | Removes all consecutive duplicate elements from the forward_list. It uses a binary predicate for comparison. |
|---|
| reverse() | Reverses the order of the elements present in the forward_list. |
|---|
clear() | Remove all elements of the forward list. |
|---|
insert_after() | Insert an element after a specific position. |
|---|
emplace_after() | Constructs elements in-place after a specific position. |
|---|
insert_range_after() | Insert range of elements after a specific position. |
|---|
erase_after() | Delete the element just after a specific position. |
|---|
push_front() | Add the new element at the beginning of the forward list. |
|---|
emplace_front() | Constructs an element in-place at the beginning of the forward list. |
|---|
pop_front() | Delete the top element of the forward list. |
|---|
swap() | Swap the values of two forward list. |
|---|
merge() | This function is used to merge sorted forward list into one. |
|---|
unique() | Remove all consecutive duplicates elements from the forward list. |
|---|
sort() | This function is used to sort the forward_list. |
|---|
remove() | Remove all occurrence of the given value. |
|---|
remove_if() | Remove all the values from the list that correspond true to the predicate or condition given as a parameter |
|---|
empty() | Check forward list is empty or not. |
|---|
Similar Reads
Forward List in C++ STL
In C++, forward_list container provides the implementation of singly linked list data structure. It stores data in non-contiguous memory where each element points to the next element in the sequence. This makes insertion and deletion faster once the position of the element is known. Example: [GFGTAB
8 min read
Commonly Used Methods
forward_list::begin() and forward_list::end() in C++ STL
Forward list in STL implements singly linked list. Introduced from C++11, the forward list is more useful than other containers in insertion, removal, and moving operations (like sort) and allows time constant insertion and removal of elements. It differs from list by the fact that the forward list
3 min read
forward_list::push_front() and forward_list::pop_front() in C++ STL
Forward list in STL implements singly linked list. Introduced from C++11, forward list are useful than other containers in insertion, removal and moving operations (like sort) and allows time constant insertion and removal of elements.It differs from list by the fact that forward list keeps track of
4 min read
forward_list assign() function in C++ STL
The forward_list::assign() is a function in C++ STL which assigns new content to a forward list, replacing its current content and adjusting its size as required.Syntax: Version 1:forward_list_name.assign(iterator it1, iterator it2) Version 2:forward_list_name.assign(int n, val) Version 3:forward_li
2 min read
forward_list::front() and forward_list::empty() in C++ STL
Forward list in STL implements singly linked list. Introduced from C++11, forward list are useful than other containers in insertion, removal and moving operations (like sort) and allows time constant insertion and removal of elements.It differs from list by the fact that forward list keeps track of
3 min read
forward_list::remove() and forward_list::remove_if() in C++ STL
Forward list in STL implements singly linked list. The forward list was introduced in C++11, and is useful than other containers in insertion, removal, and moving operations (like sort) and allows time constant insertion and removal of elements. It differs from the list by the fact that the forward
4 min read
forward_list::clear() and forward_list::erase_after() in C++ STL
Forward list in STL implements singly linked list. Introduced from C++11, forward list are useful than other containers in insertion, removal and moving operations (like sort) and allows time constant insertion and removal of elements.It differs from list by the fact that forward list keeps track of
4 min read
forward_list::reverse() in C++ STL
std::forward_list::reverse() is an inbuilt function in CPP STL which reverses the order of the elements present in the forward_list. Syntax: forwardlist_name.reverse()Parameter: The function does not accept any parameter. Return value: The function has no return value. It reverses the forward list.
1 min read
forward_list::swap() in C++ STL
The forward_list::swap() is a built-in function in CPP STL which exchanges the contents of the first given forward_list with another forward_list. Syntax: swap(forward_list first, forward_list second) or forward_list1.swap(forward_list second) Parameters: The function accepts two parameters which ar
3 min read
std::forward_list::sort() in C++ STL
Forward list in STL implements singly linked list. Introduced from C++11, forward list are useful than other containers in insertion, removal and moving operations (like sort) and allows time constant insertion and removal of elements.It differs from list by the fact that forward list keeps track of
3 min read
Forward List and List of Pairs in C++ with Examples
Forward List Forward list in STL implements singly linked list. Introduced from C++11, forward lists are more useful than other containers in insertion, removal, and moving operations (like sort) and allow time constant insertion and removal of elements. It differs from the list by the fact that the
8 min read
Forward List and List of Tuples in C++ with Examples
What is Forward List? Forward list in STL is used to implement a singly linked list. It was introduced from C++11 onwards, forward lists are more useful than other containers in insertion, removal, and moving operations (like sort) and allow time constant insertion and removal of elements. It differ
9 min read
Difference Between Forward List and List in C++
Forward List is a sequence container that allows unidirectional sequential access to its data. It contains data of the same type. In STL, it has been implemented using Singly Linked List, which requires constant time for insertion and deletion. Elements of the forward list are scattered in the memor
3 min read
Common Forward List Programs