Hash Maps in C#

Introduction:

In the field of data structures, HashMaps are an essential component because they provide a convenient way for storing and accessing data. Key-value pair management is facilitated with the Dictionary type in C#, which represents hash maps. A hash map's primary role is to store key-value relationships and provide quick access to items using distinct keys. HashMap offers quick key lookups. The time complexity of hash map insertion along with retrieval is O (1). HashMap requires O (n) space complexity. This tutorial explores the fundamentals of HashMaps in C#, explains how they are implemented, what they can do, and how important they are for programming tasks.

The Idea behind Hashmaps:

HashMaps stores data using key-value pairs, similar to a physical map with locations and their coordinates, which is a crucial thing to know about them. They belong to the C# Collections since they execute the ICollection interface.

What is HashMap:

In simple terms, a hash map is a data structure which maps values to keys by implementing an associative array. A hash function is used by a hash map to calculate an index into a collection of buckets or slots. In contrast to Java, C# lacks the HashMap class. The C# hashmap is implemented using the Hashtable class. A non-generic collections used to hold key-value pairs is called a hashtable. A hash table is also used in its implementation. It is stated in the System.Collections namespace. Different forms of data can be stored in hash tables. There may be distinct data types for the key and value. Now, you might wonder why you would need this. Consider a scenario in which you require an effective way to store and retrieve data from a sizable collection. Our favourite DS will be HashMap can help with that!

// By utilizing a dictionary to create a hash map in C# 

Dictionary hashMap = new_Dictionary();

Here, we're creating our hash map through the built-in Dictionary class in C#. Values are of integer type, whereas keys are of string type.

Syntax of Hashmaps in C#:

public class Hashtable_name : IDictionary, ICollection, IEnumerable

The IEnumerable, ISerializable, IDictionary, ICloneable interfaces, IDeserializationCallback, and ICollection are all implemented by the Hashtable type. A unique key is required by the hashtable. A null value cannot be present in the key.

Implementation of Hashmap in C#:

The process of implementation of hash map in C# entails building a database structure that makes key-value pair storing and retrieval efficient. Here's a detailed procedure on how to create a simple C# hash map:

The following is the detailed procedure for implementing HashMap in C#:

1. Describe the class HashMap: To begin with, make a class that represents the hash map. This class will have methods for maintaining the basic data structure and for addition, retrieving, as well as deleting key-value pairs.
2. Select a Data Structure: You can use an array consisting of linked lists either an array of arrays (buckets) to construct a hash map in C#. The buckets represented by each member in the array are linked lists of key-value pairs which have been hashed to the same index.
3. Hash function: Implementing a hash function which associates array indices with keys. To reduce collisions, this method must equally distribute the keys throughout the array.
4. Collision Handling: Apply the chaining technique to resolve collisions. Storing the keys within a linked list inside the relevant bucket if more than one of the keys hashes to the same index.
5. Add Method: Provide a mechanism for appending key-value pairs to the HashMap. Determine the array's index by computing the key's hash value, then append the key-value combination to the linked list at the index you determined.
6. Get Method: Put in place a procedure to get the value linked to a certain key. Compute the index from the array, calculate the key's hash value, and then look up the key inside the linked list at that position.
7. Remove method: Create a way to eliminate pairs of key values from the HashMap by using the delete method. Find the array's index, determine the key's hash value, and then eliminate the key-value pair out of the linked list at the corresponding index.
8. Handle Resizing: Insert logic in place to resize the array whenever a predetermined threshold is exceeded by the load factor or the proportion of the total number of components to the array's size. Resizing entails rehashing current elements, copying them into the new array, and generating a new array of greater size.

Features of Hashmap in C#:

HashMap in C# provides the following features:

• Quick Access: Using their keys, hash maps give users quick accessibility to elements. Under the assumption of a strong hash function and few collisions, the average time complexity for inserting an element, retrieval, as well as deletion operations is O(1).
• Dynamic Sizing: For accommodating the changing number of elements, hash maps automatically adjust their size. This guarantees the best possible use of available space and guards against performance degradation from too many collisions.
• Key Type Flexibility: C# hash maps support a wide range of key types, such as strings, custom objects, along with primitive types.
• Key-Value Pair Storage: By efficiently associating keys with their corresponding values, hash maps for storing data in the form of key-value pairs.
• Collision Resolution: HashMaps implements open addressing or chaining to smoothly manage collisions. Open addressing requires searching the array for alternate locations, whereas chaining includes storing several key-value pairs containing the same index.
• High Performance: HashMaps are suited for a variety of applications, such as caching, indexing, along with data retrieval since they provide excellent efficiency for associative array operations.

Program:

using System;

using System.Collections;

class Hashmaps {

    static void Main (string [] args) {

        Hashtable age_table = new Hashtable ();

        age_table.Add ("Person A", "20");

        age_table.Add ("Person B", "45");

        age_table.Add ("Person C", "18");

        age_table.Add ("Person D", "30");

        age_table.Add ("Person E", "24");

        foreach (DictionaryEntry element in age_table) {

            Console.WriteLine ( " The value of the key {0} is {1} ", element.Key, element.Value);

        }

    }

}

Output:

Operations performed on Hashmaps:

Retrieving and Adding elements:

• The Add () method is used to add elements to an existing hash map by giving a key a value.

age_table.Add ("King", 45);

age_table.Add ("Queen", 28);

• Values in the hash map can be retrieved by utilizing their corresponding keys to get the values.

int King_age = age_table ["King"];

Verifying elements existence:

• With the ContainsKey() function, you can validate if a key is present in the hash map.

if (age_table.ContainsKey ("Queen"))

{

    // Execute the statements when "Queen" is present in the hash map.

}

Using HashMap iterations:

• Using foreach loops, one can iterate across the HashMap.

foreach (var pair in age_table)

{

    Console.WriteLine ($"Key: {pair.Key}, Value: {pair. Value}");

}

Example:

using System;

using System.Collections;

class Hashmaps {

    static void Main (string [] args) {

        Hashtable ranking_table = new Hashtable ();

        ranking_table.Add ("Queen", "01");

        ranking_table.Add ("Ravi", "10");

        ranking_table.Add ("Raju", "03");

        foreach (DictionaryEntry element in ranking_table) {

            Console.WriteLine ( " The rank of {0} is {1} ", element.Key, element.Value);

        }

    }

}

Output:

C# includes a substitute for hashmaps. Dictionary is also used with C# hashmaps. Key-value pairs are kept in a generic collection called the Dictionary. The System includes the Dictionary class.Assortments.universal namespace. Different data types cannot be stored in a dictionary, in contrast to hash tables. The data type of the key and its value must match.

The pros and cons of the Hashmap in C#:

The following are some benefits of using C# hashmaps:

• With hashmaps, you can rapidly find and get values by using a key. O(1) is the average in time complexity.
• You can also easily insert key-value pairs using hashmaps. O(1) is the average time complexity.
• Any data object can be used as a key in a hashmap.
• A hashmap does not require you to specify its size, in contrast to arrays.

The following are some drawbacks of using C# hashmaps:

• The sequence in which elements are entered is not preserved by hashmaps.
• Hashmaps don't guarantee thread safety. This means that unknown behavior may result if several threads attempt to retrieve and alter the hashmap at the same time.

Conclusion:

The Dictionary class in C# represents hash maps, which are fundamental data structures for mapping keys into values. They are indispensable for a variety of programming jobs because they provide effective data entry, retrieval, and deletion actions. Recognizing HashMaps and their functions in C# is essential for making the most of their potential and enhancing application performance. This tutorial details completely about the hashmaps in C#, which includes the basics of hashmaps, implementation of hashmaps, features, code in C# language, Operations that can be performed on hashmaps, also includes the pros and cons of hashmaps.