unordermap用法

unordermap用法
Unordered map (also known as hash map) is a widely used data structure in computer programming, especially in the field of algorithms and data structures. It provides fast and efficient
look-up operations based on key-value pairs. In this article, we will explore the usage and implementation of the unordered map in
C++, focusing on its various functions and operations.
Before diving into the specifics of unordered map, let's first understand the concept of maps. In general, a map is an associative container that maps unique keys to associated values. It allows efficient access, insertion, and deletion of elements based on their keys. A map can be implemented using various data structures, including balanced binary search trees, linked lists, and hash tables.
An unordered map is essentially a map implemented using a hash table. It offers constant time complexity (O(1)) for search, insertion, and deletion operations on average. The hash table uses a hashing function to convert keys into indices of the underlying array. This enables fast retrieval of values associated with the keys.
To use the unordered map container in C++, you need to include
the <unordered_map> header file. Once included, you can declare an unordered map object with the desired key and value types. For example:
cpp
#include <unordered_map>
int main() {
std::unordered_map<int, std::string> myMap;
...
return 0;
}
In the above example, we declare an unordered map called
`myMap` with keys of integer type and values of string type. You can replace these types with any other desired ones, such as double, char, or even custom data types.
Now, let's explore the various functions provided by the unordered map. One of the most common operations is inserting elements into the map. The `insert` function allows you to add key-value
pairs to the map. It takes the key and value as arguments and inserts them into the map. Here's an example:
cpp
myMap.insert(std::pair<int, std::string>(42, "hello"));
In the above code, we insert the key-value pair (42, "hello") into the `myMap` unordered map.
To access the value associated with a particular key, you can use the square bracket operator ([]). The operator takes the key as an argument and returns a reference to its associated value. Here's an example:
cpp
std::string value = myMap[42];
In this code snippet, we access the value associated with the key 42 and store it in the `value` variable.
The unordered map also allows you to check the presence of a key in the map using the `count` function. It returns the number of elements with a given key. If the count is 1, it means the key is present; otherwise, it is not. Here's an example:
cpp
if (myMap.count(42) > 0) {
Key 42 exists in the map
} else {
Key 42 does not exist in the map
}
You can also retrieve the number of elements in the unordered map using the `size` function. It returns the total count of elements present in the map. Here's an example:
cpp
int numElements = myMap.size();
In this code snippet, we retrieve the number of elements in the
`myMap` unordered map and store it in the `numElements` variable.
Another useful operation is erasing elements from the unordered map. You can remove elements based on their keys using the
`erase` function. It takes the key as an argument and removes the corresponding key-value pair from the map. Here's an example:
cpp
myMap.erase(42);
In the above code, we remove the key-value pair with the key 42 from the `myMap` unordered map.
One important thing to note about unordered maps is that they do not guarantee any particular order of elements. The elements are arranged based on the hash values of their keys, which may result in a different order each time you run the program.
In conclusion, the unordered map is a powerful data structure that provides efficient look-up operations based on key-value pairs. It
offers constant-time complexity for search, insertion, and deletion operations, making it suitable for a wide range of applications. By using the various functions provided by the unordered map, you can manipulate and retrieve key-value pairs with ease. So, next time you need a fast and efficient data structure for mapping unique keys to associated values, consider using the unordered map in your C++ program.。