**Which Data Structure Is Used in Map?**

When working with maps in programming, it is important to understand the underlying data structure that is used to implement them. A map is a common data structure that allows you to store key-value pairs, where each key is unique and associated with a value. In this article, we will explore the different data structures commonly used to implement maps.

## Array

An array is a simple and straightforward data structure that can be used to implement a map. In this approach, you can use one array to store the keys and another array to store the corresponding values. The index of each key-value pair in the arrays would correspond to each other, allowing for efficient retrieval of values by their keys.

__Example:__

```
var keys = ["key1", "key2", "key3"];
var values = ["value1", "value2", "value3"];
```

This implementation has a constant time complexity of O(1) for retrieving values by their keys since you can directly access them using their index. However, it may have limitations when dealing with large maps or when there are frequent insertions or deletions.

## Linked List

A linked list is another data structure that can be used to implement a map. In this approach, each node of the linked list contains both the key and value of a key-value pair. Each node also holds a reference to the next node in the list.

```
class Node {
constructor(key, value) {
this.key = key;
this.value = value;
this.next = null;
}
}
// Creating nodes
var node1 = new Node("key1", "value1");
var node2 = new Node("key2", "value2");
var node3 = new Node("key3", "value3");
// Linking nodes
node1.next = node2;
node2.next = node3;
```

This implementation allows for dynamic resizing and efficient insertion and deletion of key-value pairs. However, the time complexity for retrieving values by their keys is O(n) in the worst case, as you may need to traverse the entire linked list.

## Hash Table

A hash table is a widely used data structure for implementing maps. It uses a technique called hashing to map keys to indices in an array, where the corresponding values are stored. The hashing function takes the key as input and returns an index in the array, allowing for fast retrieval of values by their keys.

```
// Creating a hash table
var hashTable = {};
// Adding key-value pairs
hashTable["key1"] = "value1";
hashTable["key2"] = "value2";
hashTable["key3"] = "value3";
```

This implementation offers constant time complexity O(1) for retrieving values by their keys on average. However, it may have collisions where different keys map to the same index, which can impact performance.

### Conclusion

Different data structures can be used to implement maps, each with its own advantages and limitations. Arrays offer simplicity and constant time complexity for retrieval but may have limitations when dealing with large maps or frequent insertions/deletions.

Linked lists allow for dynamic resizing and efficient insertion/deletion but have a higher time complexity for retrieval. Hash tables provide fast retrieval on average but can have collisions impacting performance. Consider the requirements of your program to choose the most suitable data structure for your map implementation.