add files

Author: jarry

data-structure/hash/HashMap.java

@@ -0,0 +1,146 @@
+// import java.util.LinkedList;
+
+public class HashMap {
+  private static final int INITIAL_CAPACITY = 10;
+  private static final double LOAD_FACTOR = 0.75;
+
+  private Entry[] table;
+  private int size;
+  private int capacity;
+
+  // 哈希表的元素结构体
+  public class Entry {
+    String key;
+    int value;
+    Entry next; // 用于链表解决冲突
+
+    public Entry(String key, int value) {
+      this.key = key;
+      this.value = value;
+      this.next = null;
+    }
+  }
+
+  // 初始化 HashMap
+  public HashMap() {
+    this.size = 0;
+    this.capacity = INITIAL_CAPACITY;
+    this.table = new Entry[this.capacity];
+  }
+
+  // 哈希函数
+  private int hash(String key) {
+    int hashValue = 0;
+    for (int i = 0; i < key.length(); i++) {
+      hashValue = (hashValue * 31) + key.charAt(i);
+    }
+    return Math.abs(hashValue) % this.capacity;
+  }
+
+  // 扩容
+  private void resize() {
+    int newCapacity = this.capacity * 2;
+    Entry[] newTable = new Entry[newCapacity];
+
+    // 迁移原表的数据到新表
+    for (int i = 0; i < this.capacity; i++) {
+      Entry entry = this.table[i];
+      while (entry != null) {
+        int newIndex = hash(entry.key) % newCapacity;
+        Entry newEntry = new Entry(entry.key, entry.value);
+        newEntry.next = newTable[newIndex];
+        newTable[newIndex] = newEntry;
+
+        entry = entry.next;
+      }
+    }
+
+    this.capacity = newCapacity;
+    this.table = newTable;
+  }
+
+  // 插入键值对（如果存在则更新）
+  public void put(String key, int value) {
+    // 判断是否需要扩容
+    if ((double) this.size / this.capacity > LOAD_FACTOR) {
+      resize();
+    }
+
+    int index = hash(key);
+    Entry entry = this.table[index];
+
+    // 遍历链表，检查是否已经存在相同的键
+    while (entry != null) {
+      if (entry.key.equals(key)) {
+        entry.value = value; // 更新值
+        return;
+      }
+      entry = entry.next;
+    }
+
+    // 如果没有找到相同的键，插入新键值对
+    Entry newEntry = new Entry(key, value);
+    newEntry.next = this.table[index];
+    this.table[index] = newEntry;
+    this.size++;
+  }
+
+  // 查找键
+  public int get(String key) {
+    int index = hash(key);
+    Entry entry = this.table[index];
+
+    while (entry != null) {
+      if (entry.key.equals(key)) {
+        return entry.value;
+      }
+      entry = entry.next;
+    }
+    return -1; // 返回 -1 表示未找到
+  }
+
+  // 删除键
+  public void delete(String key) {
+    int index = hash(key);
+    Entry entry = this.table[index];
+    Entry prev = null;
+
+    while (entry != null) {
+      if (entry.key.equals(key)) {
+        if (prev == null) {
+          this.table[index] = entry.next;
+        } else {
+          prev.next = entry.next;
+        }
+        this.size--;
+        return;
+      }
+      prev = entry;
+      entry = entry.next;
+    }
+  }
+
+  // 测试
+  public static void main(String[] args) {
+    HashMap map = new HashMap();
+    map.put("apple", 10);
+    map.put("banana", 20);
+    map.put("orange", 30);
+
+    System.out.println("apple: " + map.get("apple"));
+    System.out.println("banana: " + map.get("banana"));
+    System.out.println("grape: " + map.get("grape"));
+
+    map.delete("banana");
+    System.out.println("banana after delete: " + map.get("banana"));
+  }
+}
+
+/*
+ * jarry@MacBook-Pro hash % javac HashMap.java
+ * jarry@MacBook-Pro hash % java HashMap
+ * apple: 10
+ * banana: 20
+ * grape: -1
+ * banana after delete: -1
+ */

data-structure/hash/hash_map.c

@@ -0,0 +1,188 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define INITIAL_CAPACITY 10
+#define LOAD_FACTOR 0.75
+
+// 哈希表的元素结构体
+typedef struct Entry {
+    char *key;
+    int value;
+    struct Entry *next; // 用于链表解决冲突
+} Entry;
+
+// 哈希表结构体
+typedef struct {
+    Entry **table;    // 哈希表数组
+    int size;         // 哈希表中存储的元素数量
+    int capacity;     // 哈希表的容量
+} HashMap;
+
+// 哈希函数（使用简单的字符串哈希函数）
+unsigned int hash(const char *key, int capacity) {
+    unsigned int hashValue = 0;
+    while (*key) {
+        hashValue = (hashValue * 31) + *key;
+        key++;
+    }
+    return hashValue % capacity;
+}
+
+// 初始化 HashMap
+void initHashMap(HashMap *map) {
+    map->size = 0;
+    map->capacity = INITIAL_CAPACITY;
+    map->table = (Entry **)malloc(sizeof(Entry *) * map->capacity);
+    for (int i = 0; i < map->capacity; i++) {
+        map->table[i] = NULL;
+    }
+}
+
+// 重新分配容量，扩容 HashMap
+void resizeMap(HashMap *map) {
+    int newCapacity = map->capacity * 2;
+    Entry **newTable = (Entry **)malloc(sizeof(Entry *) * newCapacity);
+
+    // 初始化新表
+    for (int i = 0; i < newCapacity; i++) {
+        newTable[i] = NULL;
+    }
+
+    // 迁移原表数据到新表
+    for (int i = 0; i < map->capacity; i++) {
+        Entry *entry = map->table[i];
+        while (entry) {
+            int newIndex = hash(entry->key, newCapacity);
+            Entry *newEntry = (Entry *)malloc(sizeof(Entry));
+            newEntry->key = strdup(entry->key);
+            newEntry->value = entry->value;
+            newEntry->next = newTable[newIndex];
+            newTable[newIndex] = newEntry;
+
+            entry = entry->next;
+        }
+    }
+
+    // 释放原表并更新哈希表
+    for (int i = 0; i < map->capacity; i++) {
+        Entry *entry = map->table[i];
+        while (entry) {
+            Entry *next = entry->next;
+            free(entry->key);
+            free(entry);
+            entry = next;
+        }
+    }
+    free(map->table);
+    map->table = newTable;
+    map->capacity = newCapacity;
+}
+
+// 插入键值对（如果存在则更新）
+void put(HashMap *map, const char *key, int value) {
+    // 判断是否需要扩容
+    if ((float)map->size / map->capacity > LOAD_FACTOR) {
+        resizeMap(map);
+    }
+
+    int index = hash(key, map->capacity);
+    Entry *entry = map->table[index];
+
+    // 遍历链表，检查是否已经存在相同的键
+    while (entry) {
+        if (strcmp(entry->key, key) == 0) {
+            entry->value = value;  // 更新值
+            return;
+        }
+        entry = entry->next;
+    }
+
+    // 如果没有找到相同的键，插入新键值对
+    Entry *newEntry = (Entry *)malloc(sizeof(Entry));
+    newEntry->key = strdup(key);
+    newEntry->value = value;
+    newEntry->next = map->table[index];
+    map->table[index] = newEntry;
+    map->size++;
+}
+
+// 查找键
+int get(HashMap *map, const char *key) {
+    int index = hash(key, map->capacity);
+    Entry *entry = map->table[index];
+
+    while (entry) {
+        if (strcmp(entry->key, key) == 0) {
+            return entry->value;
+        }
+        entry = entry->next;
+    }
+    return -1;  // 返回 -1 表示未找到
+}
+
+// 删除键
+void delete(HashMap *map, const char *key) {
+    int index = hash(key, map->capacity);
+    Entry *entry = map->table[index];
+    Entry *prev = NULL;
+
+    while (entry) {
+        if (strcmp(entry->key, key) == 0) {
+            if (prev) {
+                prev->next = entry->next;
+            } else {
+                map->table[index] = entry->next;
+            }
+            free(entry->key);
+            free(entry);
+            map->size--;
+            return;
+        }
+        prev = entry;
+        entry = entry->next;
+    }
+}
+
+// 释放哈希表
+void freeHashMap(HashMap *map) {
+    for (int i = 0; i < map->capacity; i++) {
+        Entry *entry = map->table[i];
+        while (entry) {
+            Entry *next = entry->next;
+            free(entry->key);
+            free(entry);
+            entry = next;
+        }
+    }
+    free(map->table);
+}
+
+// 测试
+int main() {
+    HashMap map;
+    initHashMap(&map);
+
+    put(&map, "apple", 10);
+    put(&map, "banana", 20);
+    put(&map, "orange", 30);
+
+    printf("apple: %d\n", get(&map, "apple"));
+    printf("banana: %d\n", get(&map, "banana"));
+    printf("grape: %d (not found)\n", get(&map, "grape"));
+
+    delete(&map, "banana");
+    printf("banana after delete: %d\n", get(&map, "banana"));
+
+    freeHashMap(&map);
+    return 0;
+}
+
+/*
+jarry@MacBook-Pro hash % gcc hash_map.c
+jarry@MacBook-Pro hash % ./a.out 
+apple: 10
+banana: 20
+grape: -1 (not found)
+banana after delete: -1
+*/