insert(1);
insert(4);
insert(9);
insert(2);
insert(1);
insert(10);

unordered_set: 10, 2, 1, 9, 4

unordered_set<data_type>set_name;

unordered_set<data_type>set_name = {e1, e2, e3, e4, ...};
or,
unordered_set<data_type>set_name {e1, e2, e3, e4, ...};

unordered_set<data_type>set_name;

Let's explore a piece of C++ code related to the unordered set functionality.

### How is C++'s internal implementation of Unordered set done?

The storage mechanism inside unordered sets in C++ involves the utilization of a hash table. Consequently, when elements are inserted into the unordered set, they are subjected to a hashing process to generate a unique hash key, which is subsequently stored within the hash table. Due to the nature of this hashing mechanism, the elements in the unordered set are stored in a random order without any specific sequence, as the hash keys are produced through a randomized approach.

It is an additional factor that the intricacy of the hash function impacts the overall complexity of the unsorted collection. While most actions on an unsorted set in C++ generally demand O(1) constant time, there is a rare scenario where they might consume O(n) time in the worst-case scenario.

### Set vs. Unordered set

A set in C++ is an extra container type that closely resembles an unordered set. The key distinction is that while an unordered set stores elements randomly without a specific order, a set organizes them in ascending order based on their values.

Since a hash map is employed to create an unsorted collection in C++, as discussed earlier, the items are maintained in a random sequence. In contrast, the C++ set utilizes a balanced tree structure, enabling it to store elements in a sorted manner.

This difference in implementation impacts the time complexity and functionality of the containers. The C++ set typically operates at O(log(n)) time complexity, whereas the unordered set operates at O(1) time complexity for all operations. However, both containers have a space complexity of O(n) based on the number of elements they hold.

### Unordered Set Methods in C++

Let's explore the various techniques that can be employed with an unsorted collection in C++, along with their syntax and computational demands.

| Method Name | Description | Syntax | Time complexity |
| --- | --- | --- | --- |
| insert() | It is utilized to add a new element to the unordered set. | set_name.insert(element); | 0(1) |
| begin() | It gives back an iterator that goes through the unordered set's first element. | set_name.begin(); | 0(1) |
| end() | An iterator to the last element of the unordered set is returned. The location following the last element of the unordered set is indicated by this iterator. | set_name.end(); | 0(1) |
| count() | In the unordered set, it is used to determine whether an element is present. If the element is present, it yields 1, otherwise it returns 0. | set_name.count(element); | 0(1) |
| size() | It is used to return the unordered set's size or the total number of new, distinctive pieces that have been added to it. | set_name.size(); | 0(1) |
| find() | The iterator pointing to a specific value in the unordered set is located and returned using this method. If the requested element cannot be located, an iterator to the end of the unordered set is returned. | set_name.find(\*itr); | 0(1) |
| empty() | It is used to determine whether or not the unordered set is empty. If the unordered set is empty, it yields 1, otherwise it returns 0. | set_name.empty() | O(1) |
| erase() | It is used to use iterators to remove a specific element or a group of elements from the unordered set. | set_name.erase(*itr); OR set_name.erase(*itr_begin, *itr_end); | 0(number of elements removed) |
| clear() | The unordered set is totally emptied using it. | set_name.clear(); | 0(number of elements) |

### How to Iterate Over an Unordered Set's Elements in C++

In C++, arrays can be traversed using indexes, while unordered sets do not have indexes. Instead, iterators in unordered sets act as pointers to the elements. By utilizing iterators, we can iterate through the unordered set and access all its elements seamlessly.

As illustrated earlier, the begin() function provides an iterator that points to the commencement of the unsorted set, where our iteration can commence. The conclusion of our iteration will be when the iterator reaches the element following the last one in the unsorted set, which is obtained using the end() function.

Output

We cycled through the elements until we hit the end iterator, starting from the beginning of the unordered set. In C++, we can traverse through the elements of an unordered set using the method below.

## Conclusion

In C++, an unordered set serves as a container data structure designed for storing unique elements regardless of their sequence. The header file <unordered_set> includes the necessary library for working with an unordered set in C++.

A hash table is employed to establish the unordered set in C++. Operations on an unordered set in C++ generally require constant O(1) time complexity, although there are instances where they may require linear O(n) time complexity.

Set in C++ utilizes a balanced tree structure for implementation and maintains unique elements in ascending order, distinguishing it from the unordered set.

In C++, an unordered set can be interacted with through a range of functions such as insert(), begin(), end(), size(), empty(), clear(), erase(), count(), and find().