Set of List and Forward List in C++ with examples

Last Updated : 10 Nov, 2021

Sets

Sets are a type of associative container in which each element has to be unique because the value of the element identifies it. The value of the element cannot be modified once it is added to the set, though it is possible to remove and add the modified value of that element.

Functions used with Sets:

begin(): Returns an iterator to the first element in the set.
end(): Returns an iterator to the theoretical element that follows the last element in the set.
size(): Returns the number of elements in the set.
max_size(): Returns the maximum number of elements that the set can hold.
empty(): Returns whether the set is empty.

Lists

Lists are sequence containers that allow non-contiguous memory allocation. As compared to vector, the list has slow traversal, but once a position has been found, insertion and deletion are quick. Normally, when we say a List, we talk about a doubly linked list. For implementing a singly linked list, we use a forward list.

Functions used with Lists:

push_front(): This function is used to push elements into a list from the front.
push_back(): This function is used to push elements into a list from the back.

Forward Lists

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.

Functions used with Forward Lists:

push_front(): This function is used to push elements into a Forward list from the front.

Sets of List in STL

A set of lists can be very useful in designing complex data structures.

Syntax:

set<list<data_type>> set_of_list: This stores lists. 
set<forward_list<data_type>> set_of_forward_list: This stores forward lists.

Below is the C++ program to demonstrate the implementation of set of lists:

C++

// C++ program to implement 
// the above approach 
#include <bits/stdc++.h> 
using namespace std; 
  
// Function to print set contents 
void print(set<list<int> >& setOfList) 
{ 
    for (auto x : setOfList) { 
        // Each element of the set is 
        // a list itself 
        list<int> li = x; 
  
        // Printing list elements 
        cout << "[ "; 
        for (auto element : li) 
            cout << element << ' '; 
        cout << ']'; 
        cout << '\n'; 
    } 
} 
  
// Driver code 
int main() 
{ 
    set<list<int> > setOfList; 
  
    // Declaring a list 
    list<int> list1; 
  
    // Pushing elements in the list 
    // Pushing at the back 
    list1.push_back(10); 
    list1.push_back(12); 
  
    // Pushing at the front 
    list1.push_front(21); 
  
    // Pushing at the back 
    list1.push_back(16); 
  
    // Inserting a list into the set 
    setOfList.insert(list1); 
  
    // Declaring another list 
    list<int> list2; 
  
    // Pushing elements in the list 
    // Pushing at the back 
    list2.push_back(6); 
    list2.push_back(9); 
    list2.push_back(11); 
  
    // Pushing at the front 
    list2.push_front(2); 
  
    setOfList.insert(list2); 
  
    // Declaring another list 
    list<int> list3; 
  
    // Pushing elements in the list 
    // Pushing at the back 
    list3.push_back(2); 
    list3.push_back(6); 
    list3.push_back(9); 
    list3.push_back(1); 
  
    setOfList.insert(list3); 
  
    print(setOfList); 
  
    return 0; 
}

Output

[ 2 6 9 1 ]
[ 2 6 9 11 ]
[ 21 10 12 16 ]

Below is the C++ program to demonstrate the implementation of set of forward lists:

C++

// C++ program to implement 
// the above approach 
#include <bits/stdc++.h> 
using namespace std; 
  
// Function to print set contents 
void print(set<forward_list<int> >& setOfForwardList) 
{ 
    for (auto x : setOfForwardList) { 
        // Each element is a forward list 
        // itself 
        forward_list<int> li = x; 
        cout << "[ "; 
  
        for (auto element : li) 
            cout << element << ' '; 
  
        cout << ']'; 
        cout << '\n'; 
    } 
} 
  
// Driver code 
int main() 
{ 
    // Declaring a setOfForwardList 
    set<forward_list<int> > setOfForwardList; 
  
    // Declaring a forward list 
    forward_list<int> forwardList1; 
  
    // Pushing elements in the forward 
    // list 
    forwardList1.push_front(10); 
    forwardList1.push_front(12); 
    forwardList1.push_front(21); 
    forwardList1.push_front(16); 
  
    // Inserting forward list into 
    // the set 
    setOfForwardList.insert(forwardList1); 
  
    // Declaring another forward list 
    forward_list<int> forwardList2; 
  
    // Pushing elements in the forward 
    // list 
    forwardList2.push_front(6); 
    forwardList2.push_front(9); 
    forwardList2.push_front(11); 
    forwardList2.push_front(2); 
  
    // Inserting forward list into 
    // the set 
    setOfForwardList.insert(forwardList2); 
  
    // Print set contents 
    print(setOfForwardList); 
  
    return 0; 
}

Output

[ 2 11 9 6 ]
[ 16 21 12 10 ]

By default, lists are arranged in non – descending order in the set and follow the logic that in the set, if the first value of two lists is equal then the second value of lists is compared, and so on.

Suggest improvement

C++ set for user define data type

Map of list and forward_list in C++ STL with Examples

Share your thoughts in the comments