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:

#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;
}

1 5 3 4 

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:

#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;
}

4 4 4 
1 5 3 4 

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:

#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;
}

1
3

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:

#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;
}

1 5 3 4 

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:

#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;
}

111
333

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:

#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;
}

3

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:

#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;
}

1 5 3 4 

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:

#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;
}

5 3 

Time Complexity

The below table lists the time complexity of the above operations on forward list:

Other Common Operations

The following articles demonstrate some other operations that are commonly performed on a forward list container:

• Check if Forward List is Empty
• Find the Size of Forward List
• Reverse Forward List
• Sort Forward List
• Merge Two Forward List
• Swap Forward Lists
• Create Forward List of Pairs

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: