A hash table is a data structure that allows for efficient insertion, deletion, and retrieval of key-value pairs. It is also known as a hash map or associative array. In this article, we will explore an example of a hash table data structure and understand how it works.

## Understanding Hash Table

Before we dive into the example, let’s quickly review the basics of a hash table. A hash table consists of an array of fixed size, where each element in the array is called a bucket. Each bucket can store one or more key-value pairs.

To store a new key-value pair in a hash table, we need to perform two main steps:

**Hashing:**The key is hashed to generate an index that corresponds to one of the buckets in the array.**Collision Handling:**If two different keys hash to the same index (a collision), we need a strategy to handle it.

## An Example

Let’s consider an example where we want to store information about students in a class using a hash table. The keys will be student IDs, and the values will be their names.

We start by initializing an empty hash table with 10 buckets:

```
<script>
const hashTable = new Array(10);
</script>
```

To insert a student’s information into the hash table, we follow these steps:

__Hashing:__We calculate the hash value for the student ID using a hashing function. For simplicity, let’s assume our hashing function returns the remainder when dividing the student ID by 10 (to ensure it falls within our array size).__Collision Handling:__If a collision occurs (two students have the same hash value), we can handle it by using a technique called chaining. Each bucket in the hash table will be a linked list, and we will append the new key-value pair to the end of the linked list.__Insertion:__Once we have determined the correct bucket, we insert the key-value pair into it.

Let’s consider an example where we want to insert two students’ information:

```
<script>
// Insert student with ID 123
const index1 = 123 % 10;
hashTable[index1] = { id: 123, name: 'John Doe' };
// Insert student with ID 456
const index2 = 456 % 10;
hashTable[index2] = { id: 456, name: 'Jane Smith' };
</script>
```

In this example, both students have different IDs, so there are no collisions. The resulting hash table would look like this:

```
<script>
[
null,
null,
null,
null,
null,
{ id: 123, name: 'John Doe' },
{ id: 456, name: 'Jane Smith' },
null,
null,
null
]
</script>
```

### Retrieving a Value

To retrieve a student’s name from their ID, we follow these steps:

__Hashing:__We calculate the hash value for the student ID using the same hashing function used during insertion.__Retrieval:__We access the correct bucket in the hash table using the calculated index and retrieve the value associated with the given key.

Let’s retrieve the name of student with ID 123 from our example hash table:

```
<script>
// Retrieve student name for ID 123
const index = 123 % 10;
const student = hashTable[index];
const name = student ? student.name : 'Student not found';
</script>
```

In this case, since we inserted a student with ID 123, we will get their name as “John Doe.”

## Conclusion

A hash table is a powerful data structure that provides efficient key-value pair storage and retrieval. In this article, we explored an example of a hash table used to store students’ information.

We learned about hashing, collision handling, and retrieval techniques. By utilizing these concepts, we can build efficient and scalable applications that require fast data access based on keys.

Remember to experiment with different hashing functions and collision handling strategies to optimize your hash table implementation for specific use cases.