Add basic hash table implementation for person structs

Introduces a hash table in C for storing and managing person_t structs, including creation, insertion, lookup, deletion, and printing functions. Adds cperson.c/h for person struct management and hash_table.c/h for hash table logic using open addressing.

Author: XuhuaHuang

HashTable/cperson.c

@@ -0,0 +1,32 @@
+/**
+ * @file cperson.c
+ * @author Xuhua Huang
+ * @brief Implementation of functions for the CPerson struct.
+ * @version 0.1
+ * @date 2025-06-25
+ * 
+ * @copyright Copyright (c) 2025
+ * 
+ */
+
+#include "cperson.h"
+#include <stdlib.h>
+#include <string.h>
+
+person_t* DELETED_NODE = (person_t*)(0xFFFFFFFF); // Unsafe, but illustrative
+
+person_t* create_person(const char* name, int age) {
+    person_t* new_person = (person_t*)malloc(sizeof(person_t));
+    if (new_person) {
+        strncpy(new_person->name, name, sizeof(new_person->name) - 1);
+        new_person->name[sizeof(new_person->name) - 1] = '\0';
+        new_person->age = age;
+    }
+    return new_person;
+}
+
+void delete_person(person_t* person) {
+    if (person) {
+        free(person);
+    }
+}

HashTable/cperson.h

@@ -0,0 +1,22 @@
+/**
+ * @file cperson.h
+ * @author Xuhua Huang
+ * @brief Define a C-style struct for a person.
+ * @version 0.1
+ * @date 2025-06-25
+ *
+ * @copyright Copyright (c) 2025
+ *
+ */
+
+#ifndef CPERSON_H
+#define CPERSON_H
+
+typedef struct CPerson {
+    char name[100];
+    int age;
+} person_t;
+
+extern person_t* DELETED_NODE; // Pointer to a deleted node, used in hash table operations
+
+#endif // !CPERSON_H

HashTable/hash_table.c

@@ -0,0 +1,88 @@
+/**
+ * @file hash_table.c
+ * @author Xuhua Huang
+ * @brief
+ * @version 0.1
+ * @date 2025-06-25
+ *
+ * @copyright Copyright (c) 2025
+ *
+ */
+
+#include "hash_table.h"
+
+#include <stdio.h>
+#include <string.h>
+
+static person_t* hash_table[HASH_TABLE_SIZE];
+
+unsigned int hash(const char* const name) {
+    int length = strnlen(name, MAX_NAME_LENGTH);
+    unsigned int hash_value = 0;
+    for (int i = 0; i < length; ++i) {
+        hash_value += name[i];
+        hash_value = (hash_value * name[i]) % HASH_TABLE_SIZE;
+    }
+    return hash_value;
+}
+
+void init_hash_table() {
+    for (int i = 0; i < HASH_TABLE_SIZE; ++i) {
+        hash_table[i] = NULL;
+    }
+}
+
+bool insert_to_table(const person_t* const ptr) {
+    if (!ptr) return false;
+    int index = hash(ptr->name);
+    for (int i = 0; i < HASH_TABLE_SIZE; ++i) {
+        int try_index = (i + index) % HASH_TABLE_SIZE;
+        if (hash_table[try_index] == NULL) {
+            hash_table[try_index] = (person_t*)ptr;
+            return true;
+        }
+    }
+    return false;
+}
+
+person_t* hash_table_lookup(const char* const name) {
+    int index = hash(name);
+    for (int i = 0; i < HASH_TABLE_SIZE; ++i) {
+        int try_index = (i + index) % HASH_TABLE_SIZE;
+        if (hash_table[try_index] == NULL) return NULL;
+        if (hash_table[try_index] == DELETED_NODE) continue;
+        if (strncmp(hash_table[try_index]->name, name, MAX_NAME_LENGTH) == 0) {
+            return hash_table[try_index];
+        }
+    }
+    return NULL;
+}
+
+person_t* del_from_table(const char* const name) {
+    int index = hash(name);
+    for (int i = 0; i < HASH_TABLE_SIZE; ++i) {
+        int try_index = (i + index) % HASH_TABLE_SIZE;
+        if (hash_table[try_index] == NULL) return NULL;
+        if (hash_table[try_index] == DELETED_NODE) continue;
+        if (strncmp(hash_table[try_index]->name, name, MAX_NAME_LENGTH) == 0) {
+            person_t* temp = hash_table[try_index];
+            hash_table[try_index] = DELETED_NODE;
+            return temp;
+        }
+    }
+    return NULL;
+}
+
+void print_table() {
+    printf("\nStart %s\n", __FUNCTION__);
+    for (int i = 0; i < HASH_TABLE_SIZE; ++i) {
+        if (hash_table[i] == NULL) {
+            printf("\t%i\t---\n", i);
+        } else if (hash_table[i] == DELETED_NODE) {
+            printf("\t%i\t---<deleted>\n", i);
+        } else {
+            printf("\t%i\t%s\n", i, hash_table[i]->name);
+        }
+    }
+    printf("End %s\n", __FUNCTION__);
+}

HashTable/hash_table.h

@@ -0,0 +1,35 @@
+/**
+ * @file hash_table.h
+ * @author Xuhua Huang
+ * @brief Practice of hash table in C++23 after lecture of Data Structures and Algorithms.
+ * Constant operation time of O(1) with Open Addressing and External Chamber.
+ *
+ * @version 0.1
+ * @date 2025-06-25
+ *
+ * @copyright Copyright (c) 2025
+ *
+ */
+
+#ifndef HASH_TABLE_H
+#define HASH_TABLE_H
+
+#include "cperson.h"
+#include <stdbool.h>
+
+#define HASH_TABLE_SIZE 10
+#define MAX_NAME_LENGTH 100
+
+typedef struct HashTableEntry {
+    person_t person;
+    bool isOccupied; // Flag to check if the entry is occupied
+} hash_table_entry_t;
+
+unsigned int hash(const char* const name);
+void init_hash_table();
+bool insert_to_table(const person_t* const ptr);
+person_t* hash_table_lookup(const char* const name);
+person_t* del_from_table(const char* const name);
+void print_table();
+
+#endif // !HASH_TABLE_H