Sequence and Associative Containers in C++

A Container in C++ is an object that stores collections of additional information. These packages can hold any data type, particularly user-defined data types, because they are implemented as class templates. In C++, there are three kinds of containers: sequential containers, associative containers, and unorganized (associative) containers.

Sequential Containers

An ordered group of the same kind of data in C++, where each element is kept at a designated location, is called a sequential container. The position of an element is determined by the location and timing of its insertion. Sequential containers are sometimes referred to as sequence containers. There are 3 types of sequential containers:

1. Arrays:

Arrays are containers with a defined size. They have a limited number of components. These components are placed in a tight linear order. We can use array items directly by giving their index, so we don't have to traverse the entire array.

Example:

Let's take a C++ example to illustrate the use of array in sequence containers:

#include <iostream>
 #include <array>
 using namespace std;
 int main()
 {
 // array creation
 array<int, 5> a = {11, 16, 19, 10, 14};
 // creation of the iterator
 array<int, 5>::iterator ite;
 // The values of the array is iterated
 cout << "The array is: ";
 for(ite = a.begin(); ite < a.end(); ite++)
 {
 cout << *ite << " ";
 }
 cout << endl;
 cout << "The Size of the array given array is: " << a.size() << endl;
 return 0;
 }

Output:

The array is: 11 16 19 10 14 
The Size of the array given array is: 5

Explanation:

In this program, we made use of the array standard library to build an array a. After that, we used many array library specified functions. The methods begin() and end() return the pointer to the array's beginning and last members. The size() function returns the size of the array.

2. Vectors

The vectors are array containers that may change in size. Vectors, like arrays, employ contiguous regions of memory to hold their items. However, unlike arrays, the size of a vector's data can change constantly, and storage is handled effectively by the container that holds it.

Example:

Let's take a C++ example to illustrate the use of Vectors in sequence containers:

#include <iostream>
 #include <vector>

 using namespace std;

 int main()
 {
 vector<int> vect;

 for (int i = 1; i <= 40; i = i * 2)
 vect.push_back(i);

 cout << "The output with vect.begin() and vect.end(): ";
 for (auto i = vect.begin(); i != vect.end(); i++)
 cout << *i << " ";

 cout << "\nThe output with vect.rbegin() and vect.rend(): ";
 for (auto ite = vect.rbegin(); ite != vect.rend(); ite++)
 cout << *ite << " ";

 return 0;
 }

Output:

The output with vect.begin() and vect.end(): 1 2 4 8 16 32 
The output with vect.rbegin() and vect.rend(): 32 16 8 4 2 1

Explanation:

In this example, we constructed a vector vect. We added components to this vector using the push_back() method. After that, we made use of the begin() and end() operations, as well as the rbegin() and rend() functions, to generate a print of the vector from left to right and right to left.

3. Deque:

Deque is an abbreviation for double-ended queue. A deque is a container with dimensions that can change dynamically on both ends. We may access individual elements of a Deque using random access iterators (generalization pointers that can read, write, and provide random access to containers).

Example:

Let's take a C++ example to illustrate the use of Deque in sequence containers:

#include <iostream>
 #include <deque>

 using namespace std;

 int main()
 {
 deque<int> deq;

 deq.push_back(10); // adding element to the back of the queue
 deq.push_front(20); // element was added to front
 deq.push_back(30); 
 deq.push_front(40); 


 deque<int>::iterator ite;

 cout << "The dequeue is: ";
 for (ite = deq.begin(); ite != deq.end(); ite++)
 {	
 cout << *ite << " ";
 }

 cout << "\nThe size deq.size(): " << deq.size();

 //The first element of the array is
 deq.pop_front();

 cout << "\nThe Deque after using pop_front() is: ";
 for (ite = deq.begin(); ite != deq.end(); ite++)
 {	
 cout << *ite << " ";
 }

 return 0;
 }

Output:

The dequeue is: 40 20 10 30 
The size deq.size(): 4
The Deque after using pop_front() is: 20 10 30

Associative containers

Associative containers are ones in which the position of an element is determined by its value. The sequence in which items are inserted has no impact on the element's location. The keys, sometimes known as search keys, are used to access the components in an associative container.

There are 4 different kinds of associative containers:

1. Set

A set is a container that requires each element (or key) to be unique. Once an element is added to a set, it cannot be changed. However, the element can be deleted from the set. A set's elements are kept in a sorted manner to allow for easy storage and retrieval.

Example:

Let's take a C++ example to illustrate the use of Set in Associative containers:

#include <iostream>
 // #include <iterator>
 #include <set>
 using namespace std;
 int main()
 {
 // declaring the empty set
 set<int> ss1;

 // a set ierator is declared
 set<int>::iterator ite;

 //The elements of the array are randomly arranged
 ss1.insert(50);
 ss1.insert(70);
 ss1.insert(80);
 ss1.insert(90);

 // adding 50 to the set again
 ss1.insert(50);

 // display of set 1
 cout << "The set ss1 is -> ";
 for (ite = ss1.begin(); ite != ss1.end(); ite++) 
 {
 cout << *ite << " ";
 }
 cout << endl << endl;


 // removal of element
 ss1.erase(50);

 cout << "Set ss1 after the using of s1.erase(50) method-> ";
 for (ite = ss1.begin(); ite != ss1.end(); ite++) 
 {
 cout << *ite << " ";
 }

 return 0;
 }

Output:

The set ss1 is -> 50 70 80 90 
Set ss1 after the using of s1.erase(50) method-> 70 80 90

Explanation:

In this example, we tried to put the number 50 twice into the set. However, 50 have been added to the set once because every component in a set must be unique. After that, the set element was removed using the erase() method.

2. Multiset

Multisets are containers that are identical to sets but accept duplicate items (keys). The value of a single element in a multiset cannot be changed after it has been saved, although the element may be removed from the set's container.

Example:

Let's take a C++ example to illustrate the use of Multiset in Associative containers:

 #include <iostream>
 #include <set>

 using namespace std;

 int main()
 {
 // declaring an empty multiset
 multiset<int> mset1;

 //The elements are inserted in random order
 mset1.insert(60);
 mset1.insert(80);
 mset1.insert(40);
 mset1.insert(30);

 // 30 is added to the set twice
 mset1.insert(30);

 // the display of multi set
 multiset<int>::iterator ite;
 cout << "The multiset ms1 is: " << endl;
 for (ite = mset1.begin(); ite != mset1.end(); ite++) 
 {
 cout << *ite << " ";
 }

 cout << endl << endl;

 // Remove all items in ms1 up to the one with value 40.
 cout << "The multiset after the removal of values< 40: " << endl;
 mset1.erase(mset1.begin(), mset1.find(40));

 for (ite = mset1.begin(); ite != mset1.end(); ite++) 
 {
 cout << *ite << " ";
 }

 return 0;
 }

Output:

The multiset ms1 is: 
30 30 40 60 80 

The multiset after the removal of values< 40: 
40 60 80

Explanation:

In this example, we were able to add element 30 twice in the given application because multisets enable element duplication. We additionally utilized the erase() method to delete all elements in the multiset that were less than 40. The wipe function could have erased the whole multiset if 40 had not been included in the set.

3. Map

A Map is a container that holds data in the form of key-value pairs. A map container's variables must be unique, and each key must have only one value attached to it. The data type that makes up the key and the value associated with it may differ. A map's components are kept in relation to the key. Any element can be added or removed.

Example:

Let's take a C++ example to illustrate the use of Map in Associative containers:

 #include <iostream>
 #include <map>

 using namespace std;

 int main()
 {
 //An empty map container is declared
 map<int, char> map1;

 map<int, char>::iterator ite;

 // elements are inserting
 map1.insert(pair<int, char>(1, 'c'));
 map1.insert(pair<int, char>(3, 'h'));
 map1.insert(pair<int, char>(4, 'i'));
 map1.insert(pair<int, char>(5, 'c'));
 map1.insert(pair<int, char>(2, 'k'));


 //display of the mapped values

 cout << "The map map1 contains: " << endl;

 cout << "KEY -> VALUE" << endl;
 for (ite = map1.begin(); ite != map1.end(); ++ite)
 {
 cout << " " << ite->first << " -> " 
 << ite->second << endl;
 }

 cout << endl;

 //The element with key 4 is removed
 map1.erase(4);
 cout << "After running m1.erase(4), the map is: " << endl;

 cout << "KEY -> VALUE" << endl;
 for (ite = map1.begin(); ite != map1.end(); ++ite)
 {
 cout << " " << ite->first << " -> " 
 << ite->second << endl;
 }

 return 0;
 }

Output:

The map map1 contains: 
KEY -> VALUE
 1 -> c
 2 -> k
 3 -> h
 4 -> i
 5 -> c

After running m1.erase(4), the map is: 
KEY -> VALUE
 1 -> c
 2 -> k
 3 -> h
 5 -> c

Explanation:

In this example, we created a map and used the insert() method to add entries to it. After that, a component with key = 4 was removed using the erase() method.

4. Multimap

Multimap containers have similarities to map containers, except they enable Multiple keys to be stored in a container. As a result, the key-value pairs have a one-to-many connection. In multimaps, the key's datatype might differ from its corresponding value's.

Example:

Let's take a C++ example to illustrate the use of Multimap in Associative containers:

#include <iostream>
 #include <map>

 using namespace std;

 int main()
 {
 // An empty multimap is initialized
 multimap<int, int> mmap1; 

 multimap<int, int>::iterator ite;

 // values are inserted into the multimap
 mmap1.insert(pair<int, int>(35, 4));
 mmap1.insert(pair<int, int>(31, 3));
 mmap1.insert(pair<int, int>(61, 6));
 mmap1.insert(pair<int, int>(90, 9));
 mmap1.insert(pair<int, int>(34, 1));

 // Display oof multimap1
 cout << "The multimap m1 ha elements: " << endl;

 cout << "KEY -> VALUE" << endl;
 for (ite = mmap1.begin(); ite != mmap1.end(); ite++) 
 {
 cout << " " << ite->first << " -> " 
 << ite->second << endl;
 }

 cout << endl;

 // removing the elements upto the specific key value
 mmap1.erase(mmap1.begin(), mmap1.find(31));

 cout << "The multimap mmap1 after removing the key values upto (31 " << endl;

 cout << "KEY -> VALUE" << endl;
 for (ite = mmap1.begin(); ite != mmap1.end(); ite++) 
 {
 cout << " " << ite->first << " -> " 
 << ite->second << endl;
 }

 return 0;
 }

Output:

The multimap m1 ha elements: 
KEY -> VALUE
 31 -> 3
 34 -> 1
 35 -> 4
 61 -> 6
 90 -> 9

The multimap mmap1 after removing the key values up to (31 KEY -> VALUE
 31 -> 3
 34 -> 1
 35 -> 4
 61 -> 6
 90 -> 9

Explanation:

In this example, we constructed a multimap. After that, we can use the same key twice in the multimap because it enables duplicate key values. We used the erase() method to eliminate all entries with key numbers less than 31.

Main Differences between Sequence and Associative Containers in C++:

These are the differences between Sequence and Associative containers in C++:

Aspect	Sequence containers	Associative containers
Order	Keep the components in their proper arrangement.	There is no assurance of order; items may be sorted using keys.
Performance	Lookup takes longer (O(n) for linear structures like lists, and O(log n) for vectors).	On average, quicker lookup (O(log n) for symmetrical trees, O(1) for hash arrays).
Access	Iterators, indices, and range-based loops may all access it.	Unique keys linked with every component allow access.
Storage Structure	Arrays, linked lists, or dynamic arrays are common implementations.	Trees (map, multimap, set, multiset) or hashing (unordered_map, unordered_set) are used.
Duplicates	Allow for duplication; elements might appear more than once.	Keys must be distinct; each key can only map to one value.