GeeksforGeeks App
Open App
Browser
Continue

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

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 ``using` `namespace` `std;`` ` `// Function to print set contents``void` `print(set >& 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 > 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 ``using` `namespace` `std;`` ` `// Function to print set contents``void` `print(set >& 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 > 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.

My Personal Notes arrow_drop_up