hash_table

Data Structure: Hash Table

A hash table is a data structure that implements an associative array, a structure that can map keys to values. Hash tables are designed to provide efficient insertion, deletion, and lookup operations, typically achieving average-case constant-time complexity (O(1)) for these operations. Hash tables are widely used in various programming languages and are fundamental to many implementations of associative containers, such as std::unordered_map and std::unordered_set in C++.

Key Concepts of Hash Tables

• Hash Function: A hash function takes a key and computes an integer, called the hash code, which is used as an index into an array (called a bucket array) where the corresponding value is stored.
• Buckets: The hash table uses an array of buckets, where each bucket can hold one or more key-value pairs. A good hash function distributes keys evenly across buckets to minimize collisions.
• Collisions: When two different keys hash to the same index, a collision occurs. Hash tables handle collisions using various techniques, such as chaining or open addressing.
• Load Factor: The load factor is the ratio of the number of stored elements to the number of buckets in the hash table. A higher load factor increases the likelihood of collisions, potentially degrading performance.
• Rehashing: When the load factor exceeds a certain threshold, the hash table may resize itself (rehash) to maintain efficiency, redistributing the elements into a larger array of buckets.

Basic Operations in a Hash Table

• Insertion: Adding a key-value pair to the hash table.
• Lookup: Retrieving the value associated with a specific key.
• Deletion: Removing a key-value pair from the hash table.
• Handling Collisions: Managing situations where multiple keys hash to the same bucket.

Example 1: Conceptual Implementation of a Hash Table

Let's explore a simple, conceptual implementation of a hash table in C++ using chaining for collision resolution.

#include <iostream>
#include <vector>
#include <list>
#include <string>

// Simple hash function
int hashFunction(const std::string& key, int tableSize) {
    int hashValue = 0;
    for (char ch : key) {
        hashValue += ch;
    }
    return hashValue % tableSize;
}

class HashTable {
public:
    HashTable(int size) : table(size) {}

    void insert(const std::string& key, int value) {
        int hashValue = hashFunction(key, table.size());
        table[hashValue].emplace_back(key, value);
    }

    bool lookup(const std::string& key, int& value) {
        int hashValue = hashFunction(key, table.size());
        for (auto& [k, v] : table[hashValue]) {
            if (k == key) {
                value = v;
                return true;
            }
        }
        return false;
    }

    void remove(const std::string& key) {
        int hashValue = hashFunction(key, table.size());
        table[hashValue].remove_if([&](const std::pair<std::string, int>& item) {
            return item.first == key;
        });
    }

private:
    std::vector<std::list<std::pair<std::string, int>>> table;
};

int main() {
    HashTable ht(10);

    // Insert key-value pairs
    ht.insert("apple", 100);
    ht.insert("banana", 150);
    ht.insert("orange", 200);

    // Lookup values
    int value;
    if (ht.lookup("banana", value)) {
        std::cout << "Value for 'banana': " << value << std::endl;
    } else {
        std::cout << "'banana' not found." << std::endl;
    }

    // Remove a key-value pair
    ht.remove("banana");
    if (ht.lookup("banana", value)) {
        std::cout << "Value for 'banana': " << value << std::endl;
    } else {
        std::cout << "'banana' not found." << std::endl;
    }

    return 0;
}

Explanation:

• Hash Function: The hashFunction calculates the hash value by summing the ASCII values of the characters in the key and taking the modulus with the table size.
• Chaining: The hash table is implemented using an array of lists. Each list (bucket) stores key-value pairs that hash to the same index.
• Insertion: The insert method adds key-value pairs to the appropriate bucket.
• Lookup: The lookup method searches for a key in the appropriate bucket and retrieves its associated value.
• Deletion: The remove method deletes the key-value pair from the appropriate bucket.

Collision Resolution Techniques

There are two primary methods to handle collisions in a hash table: - Chaining: Each bucket in the hash table contains a list of entries that hash to the same index. This method is simple and easy to implement. - Open Addressing: When a collision occurs, the hash table probes the array to find the next available bucket. Techniques include linear probing, quadratic probing, and double hashing.

Example 2: Open Addressing with Linear Probing

#include <iostream>
#include <vector>
#include <string>

class HashTable {
public:
    HashTable(int size) : table(size, ""), values(size, 0), size(size) {}

    void insert(const std::string& key, int value) {
        int index = hashFunction(key);
        while (!table[index].empty()) {
            index = (index + 1) % size;  // Linear probing
        }
        table[index] = key;
        values[index] = value;
    }

    bool lookup(const std::string& key, int& value) {
        int index = hashFunction(key);
        while (!table[index].empty()) {
            if (table[index] == key) {
                value = values[index];
                return true;
            }
            index = (index + 1) % size;  // Linear probing
        }
        return false;
    }

    void remove(const std::string& key) {
        int index = hashFunction(key);
        while (!table[index].empty()) {
            if (table[index] == key) {
                table[index] = "";  // Mark as deleted
                return;
            }
            index = (index + 1) % size;  // Linear probing
        }
    }

private:
    int hashFunction(const std::string& key) {
        int hashValue = 0;
        for (char ch : key) {
            hashValue += ch;
        }
        return hashValue % size;
    }

    std::vector<std::string> table;
    std::vector<int> values;
    int size;
};

int main() {
    HashTable ht(10);

    ht.insert("apple", 100);
    ht.insert("banana", 150);
    ht.insert("orange", 200);

    int value;
    if (ht.lookup("banana", value)) {
        std::cout << "Value for 'banana': " << value << std::endl;
    }

    ht.remove("banana");
    if (!ht.lookup("banana", value)) {
        std::cout << "'banana' not found." << std::endl;
    }

    return 0;
}

Explanation:

• Open Addressing with Linear Probing: This method stores elements directly in the hash table array. If a collision occurs, the algorithm probes subsequent indices (in this case, linearly) until an empty bucket is found.
• Handling Deletions: The deletion operation in open addressing may require marking the position as "deleted" rather than clearing it, to avoid disrupting the probing sequence.

Advantages and Disadvantages of Hash Tables

Advantages:

• Efficiency: Hash tables offer average-case constant-time complexity for insertions, deletions, and lookups.
• Flexibility: They can store various types of data and are easily adapted for custom key types.

Disadvantages:

• Worst-Case Performance: In the worst case, such as when many collisions occur or during rehashing, operations can degrade to linear time.
• Memory Usage: Hash tables may use more memory than other data structures due to the need to allocate space for the bucket array and handle collisions.

Practical Applications

Hash tables are widely used in various real-world applications: - Associative Containers: Implementing maps, dictionaries, and sets in programming languages. - Database Indexing: Storing indexes for quick access to database records. - Caching: Implementing caches where key-value pairs are stored for fast retrieval.

Summary

• Hash Table: A data structure that maps keys to values using a hash function to compute an index into an array of buckets.
• Efficiency: Provides average-case constant-time complexity for insertion, deletion, and lookup operations.
• Collision Handling: Can be handled through techniques like chaining and open addressing.
• Real-World Use: Used extensively in associative containers, database indexing, and caching.

Hash tables are a fundamental data structure in computer science, offering a highly efficient way to manage and access data based on keys. Understanding hash tables and their underlying principles is crucial for both theoretical and practical applications in programming.