Hash Table

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define SIZE 10

// One key-value pair. next links pairs in the same bucket (chaining).
typedef struct Node {
    char key[50];
    int value;
    struct Node *next;
} Node;

Node *buckets[SIZE]; // array of buckets, each a linked list

// Hash function: sum character codes, then take remainder by SIZE.
int hash(const char *key) {
    int sum = 0;
    for (int i = 0; key[i] != '\0'; i++) {
        sum += (int)key[i];
    }
    return sum % SIZE;
}

// Insert or update a key.
void insert(const char *key, int value) {
    int index = hash(key);
    Node *cur = buckets[index];
    while (cur != NULL) {
        if (strcmp(cur->key, key) == 0) { // key exists, update it
            cur->value = value;
            return;
        }
        cur = cur->next;
    }
    Node *node = (Node *)malloc(sizeof(Node)); // new pair at front of bucket
    strcpy(node->key, key);
    node->value = value;
    node->next = buckets[index];
    buckets[index] = node;
}

// Search returns value, or -1 if the key is missing.
int search(const char *key) {
    int index = hash(key);
    Node *cur = buckets[index];
    while (cur != NULL) {
        if (strcmp(cur->key, key) == 0) return cur->value;
        cur = cur->next;
    }
    return -1;
}

// Delete removes a key from its bucket.
void deleteKey(const char *key) {
    int index = hash(key);
    Node *cur = buckets[index];
    Node *prev = NULL;
    while (cur != NULL) {
        if (strcmp(cur->key, key) == 0) {
            if (prev == NULL) buckets[index] = cur->next;
            else prev->next = cur->next;
            free(cur);
            return;
        }
        prev = cur;
        cur = cur->next;
    }
}

int main() {
    for (int i = 0; i < SIZE; i++) buckets[i] = NULL;

    insert("riya", 98765); // riya and dan both hash to bucket 7
    insert("dan", 33445);  // they chain together in the same bucket
    insert("alex", 30099);

    printf("Search riya: %d\n", search("riya"));
    printf("Search dan: %d\n", search("dan"));

    deleteKey("riya"); // remove riya, dan stays in the same bucket
    printf("Search riya after delete: %d\n", search("riya"));
    printf("Search dan after delete: %d\n", search("dan"));

    return 0;
}

#include <iostream>
#include <vector>
#include <list>
#include <string>
using namespace std;

const int SIZE = 10;

class HashTable {
    // Each bucket is a list of (key, value) pairs.
    vector<list<pair<string, int>>> buckets;

    // Hash function: sum character codes, then take remainder by SIZE.
    int hash(const string &key) {
        int sum = 0;
        for (char c : key) sum += (int)c;
        return sum % SIZE;
    }

public:
    HashTable() : buckets(SIZE) {}

    // Insert or update a key.
    void insert(const string &key, int value) {
        int index = hash(key);
        for (auto &pair : buckets[index]) {
            if (pair.first == key) { // key exists, update it
                pair.second = value;
                return;
            }
        }
        buckets[index].push_back({key, value}); // new pair in this bucket
    }

    // Search returns value, or -1 if the key is missing.
    int search(const string &key) {
        int index = hash(key);
        for (auto &pair : buckets[index]) {
            if (pair.first == key) return pair.second;
        }
        return -1;
    }

    // Delete removes a key from its bucket.
    void deleteKey(const string &key) {
        int index = hash(key);
        auto &bucket = buckets[index];
        for (auto it = bucket.begin(); it != bucket.end(); ++it) {
            if (it->first == key) {
                bucket.erase(it);
                return;
            }
        }
    }
};

int main() {
    HashTable table;

    table.insert("riya", 98765); // riya and dan both hash to bucket 7
    table.insert("dan", 33445);  // they chain together in the same bucket
    table.insert("alex", 30099);

    cout << "Search riya: " << table.search("riya") << endl;
    cout << "Search dan: " << table.search("dan") << endl;

    table.deleteKey("riya"); // remove riya, dan stays in the same bucket
    cout << "Search riya after delete: " << table.search("riya") << endl;
    cout << "Search dan after delete: " << table.search("dan") << endl;

    return 0;
}

import java.util.LinkedList;

public class HashTableDemo {
    static final int SIZE = 10;

    // One key-value pair stored inside a bucket.
    static class Pair {
        String key;
        int value;
        Pair(String key, int value) { this.key = key; this.value = value; }
    }

    // Each bucket is a linked list of pairs.
    static LinkedList<Pair>[] buckets = new LinkedList[SIZE];

    // Hash function: sum character codes, then take remainder by SIZE.
    static int hash(String key) {
        int sum = 0;
        for (int i = 0; i < key.length(); i++) sum += (int) key.charAt(i);
        return sum % SIZE;
    }

    // Insert or update a key.
    static void insert(String key, int value) {
        int index = hash(key);
        if (buckets[index] == null) buckets[index] = new LinkedList<>();
        for (Pair p : buckets[index]) {
            if (p.key.equals(key)) { // key exists, update it
                p.value = value;
                return;
            }
        }
        buckets[index].add(new Pair(key, value)); // new pair in this bucket
    }

    // Search returns value, or -1 if the key is missing.
    static int search(String key) {
        int index = hash(key);
        if (buckets[index] != null) {
            for (Pair p : buckets[index]) {
                if (p.key.equals(key)) return p.value;
            }
        }
        return -1;
    }

    // Delete removes a key from its bucket.
    static void deleteKey(String key) {
        int index = hash(key);
        if (buckets[index] != null) {
            buckets[index].removeIf(p -> p.key.equals(key));
        }
    }

    public static void main(String[] args) {
        insert("riya", 98765); // riya and dan both hash to bucket 7
        insert("dan", 33445);  // they chain together in the same bucket
        insert("alex", 30099);

        System.out.println("Search riya: " + search("riya"));
        System.out.println("Search dan: " + search("dan"));

        deleteKey("riya"); // remove riya, dan stays in the same bucket
        System.out.println("Search riya after delete: " + search("riya"));
        System.out.println("Search dan after delete: " + search("dan"));
    }
}

SIZE = 10

class HashTable:
    def __init__(self):
        # Each bucket is a list of [key, value] pairs.
        self.buckets = [[] for _ in range(SIZE)]

    # Hash function: sum character codes, then take remainder by SIZE.
    def hash(self, key):
        total = 0
        for ch in key:
            total += ord(ch)
        return total % SIZE

    # Insert or update a key.
    def insert(self, key, value):
        index = self.hash(key)
        for pair in self.buckets[index]:
            if pair[0] == key:        # key exists, update it
                pair[1] = value
                return
        self.buckets[index].append([key, value])  # new pair in this bucket

    # Search returns value, or -1 if the key is missing.
    def search(self, key):
        index = self.hash(key)
        for pair in self.buckets[index]:
            if pair[0] == key:
                return pair[1]
        return -1

    # Delete removes a key from its bucket.
    def delete(self, key):
        index = self.hash(key)
        bucket = self.buckets[index]
        for i in range(len(bucket)):
            if bucket[i][0] == key:
                bucket.pop(i)
                return


table = HashTable()

table.insert("riya", 98765)  # riya and dan both hash to bucket 7
table.insert("dan", 33445)   # they chain together in the same bucket
table.insert("alex", 30099)

print("Search riya:", table.search("riya"))
print("Search dan:", table.search("dan"))

table.delete("riya")  # remove riya, dan stays in the same bucket
print("Search riya after delete:", table.search("riya"))
print("Search dan after delete:", table.search("dan"))

const SIZE = 10;

class HashTable {
  constructor() {
    // Each bucket is an array of [key, value] pairs.
    this.buckets = Array.from({ length: SIZE }, () => []);
  }

  // Hash function: sum character codes, then take remainder by SIZE.
  hash(key) {
    let sum = 0;
    for (let i = 0; i < key.length; i++) {
      sum += key.charCodeAt(i);
    }
    return sum % SIZE;
  }

  // Insert or update a key.
  insert(key, value) {
    const index = this.hash(key);
    for (const pair of this.buckets[index]) {
      if (pair[0] === key) {      // key exists, update it
        pair[1] = value;
        return;
      }
    }
    this.buckets[index].push([key, value]); // new pair in this bucket
  }

  // Search returns value, or -1 if the key is missing.
  search(key) {
    const index = this.hash(key);
    for (const pair of this.buckets[index]) {
      if (pair[0] === key) return pair[1];
    }
    return -1;
  }

  // Delete removes a key from its bucket.
  delete(key) {
    const index = this.hash(key);
    const bucket = this.buckets[index];
    for (let i = 0; i < bucket.length; i++) {
      if (bucket[i][0] === key) {
        bucket.splice(i, 1);
        return;
      }
    }
  }
}

const table = new HashTable();

table.insert("riya", 98765); // riya and dan both hash to bucket 7
table.insert("dan", 33445);  // they chain together in the same bucket
table.insert("alex", 30099);

console.log("Search riya:", table.search("riya"));
console.log("Search dan:", table.search("dan"));

table.delete("riya"); // remove riya, dan stays in the same bucket
console.log("Search riya after delete:", table.search("riya"));
console.log("Search dan after delete:", table.search("dan"));