【数据结构】哈希

已于 2023-03-05 10:15:03 修改
阅读量48 收藏
点赞数
分类专栏： 数据结构系列 文章标签： 哈希算法 数据结构 散列表
于 2022-10-02 18:00:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sustzc/article/details/127144841
版权

文章目录

1. 哈希表

1.1 Makefile

.PHONY: clean

CC = gcc
CFLAGS = -g -Wall -DDEBUG
EXTRA_FLAGS = -DUSE_SQUARE_DECTIVE

# match *.c
SOURCE = $(wildcard ./*.c)
# replace * with *.c
BIN = $(patsubst %.c, %, $(notdir $(SOURCE)))

$(BIN): $(SOURCE)
	$(CC) $(CFLAGS) $(EXTRA_FLAGS) $(SOURCE) -o $@

clean:
	rm -rf $(BIN)

1.2 hash_table.h

#ifndef __HASH_TABLE_H__
#define __HASH_TABLE_H__

#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <limits.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef int key_t;
typedef int value_t;

typedef struct {
    key_t key;
    value_t value;
} kv_pair_t;

// 哈希表里存储数据的状态
typedef enum {
    EMPTY_DATA = 0, // 之前没有存过数
    EXIST_DATA, // 目前存在数
    DELETED_DATA // 曾经存在数，现在被删除了
} state_e;

typedef enum {
    HASH_TABLE_OK                               = 0,
    HASH_TABLE_NOT_FOUND                        = -0x0001,
    HASH_TABLE_ERR_NULL_POINTER                 = -0x0002,
    HASH_TABLE_ERR_CREATE_HEAP_FAILED           = -0x0003,
    HASH_TABLE_NO_CAPACITY                      = -0x0004,
    HASH_TABLE_ERR_EXPANSION_FAILED             = -0x0005,
    HASH_TABLE_ERR_UNKNOWN                      = -0X0006
} hash_table_error_code_e;

// 哈希表里每个数据的类型
typedef struct {
    state_e state;
    kv_pair_t kv_data;
} hash_data_t;

typedef size_t (*hash_func_handler)(key_t, size_t);

// 哈希表
typedef struct {
    hash_data_t *hash_data; // 实际存储空间
    size_t capacity; // 容量
    size_t size; // 实际已存储的数据个数
    hash_func_handler hash_func; // 哈希函数
} hash_table_t;

// 取模函数
size_t mod_func(key_t key, size_t capacity);
// 哈希表的初始化
hash_table_error_code_e hash_table_init(hash_table_t *hash_table,
                                        size_t capacity,
                                        hash_func_handler hash_func);

size_t get_hash_table_capacity(const hash_table_t *hash_table);

size_t get_hash_table_size(const hash_table_t *hash_table);

void print_hash_table(const hash_table_t *hash_table);
// 哈希表的查找，如果找到了则返回下标，没找到的话返回 (size_t)-1
size_t hash_table_find_by_key(const hash_table_t *hash_table, key_t key);

value_t get_value_by_key(const hash_table_t *hash_table, key_t key);

hash_table_error_code_e hash_table_insert_kv_pair(hash_table_t *hash_table,
                                                  key_t key,
                                                  value_t value);

hash_table_error_code_e hash_table_remove_by_key(hash_table_t *hash_table, key_t key);

void hash_table_destroy(hash_table_t *hash_table);

#ifdef __cplusplus
}
#endif

#endif // __HASH_TABLE_H__

1.3 hash_table.c

#include "hash_table.h"

static size_t get_next_prime_number(size_t num)
{
    size_t i = 0;
    static const size_t prime_list[] = {
        11ul, 23ul, 37ul, 47ul,
        53ul, 97ul, 193ul, 389ul, 769ul,
        1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
        49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
        1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
        50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
        1610612741ul, 3221225473ul, 4294967291ul
    };

    for (i = 0; i < sizeof(prime_list) / sizeof(size_t); ++i) {
        if (prime_list[i] >= num) {
            return prime_list[i];
        }
    }

    return (size_t)-1;
}

size_t mod_func(key_t key, size_t capacity)
{
    return (size_t)key % capacity;
}

#ifdef USE_SQUARE_DECTIVE
static size_t square_dective(size_t index, size_t capacity, size_t times)
{
    return mod_func(index + times * times, capacity);
}
#else
static size_t linear_dective(size_t index, size_t capacity)
{
    return mod_func(++index, capacity);
}
#endif /// USE_SQUARE_DECTIVE

hash_table_error_code_e hash_table_init(hash_table_t *hash_table,
                                        size_t capacity,
                                        hash_func_handler hash_func)
{
    hash_table_error_code_e ret = HASH_TABLE_OK;
    size_t i = 0;

    do {
        if (NULL == hash_table) {
            printf("hash_table is NULL\n");
            ret = HASH_TABLE_ERR_NULL_POINTER;
            break;
        }

        capacity = get_next_prime_number(capacity);
        if ((size_t)-1 == capacity) {
            printf("get_next_prime_number fail\n");
            ret = HASH_TABLE_NO_CAPACITY;
            break;
        }

        hash_table->hash_data = (hash_data_t *)calloc(1, sizeof(hash_data_t) * capacity);
        if (NULL == hash_table->hash_data) {
            perror("calloc hash_table->hash_data fail");
            ret = HASH_TABLE_ERR_CREATE_HEAP_FAILED;
            break;
        }

        hash_table->size = 0;
        hash_table->capacity = capacity;
        hash_table->hash_func = hash_func;

        for (i = 0; i < capacity; ++i) {
            hash_table->hash_data[i].state = EMPTY_DATA;
        }
    } while (0);

    return ret;
}

size_t get_hash_table_capacity(const hash_table_t *hash_table)
{
    return hash_table ? hash_table->capacity : 0;
}

size_t get_hash_table_size(const hash_table_t *hash_table)
{
    return hash_table ? hash_table->size : 0;
}

char *enum_state_2_strings(state_e state)
{
    char *state_strings = NULL;

    switch (state) {
    case EMPTY_DATA:
        state_strings = "EMPTY";
        break;
    case EXIST_DATA:
        state_strings = "EXIST";
        break;
    case DELETED_DATA:
        state_strings = "DELETE";
        break;
    default:
        break;
    }

    return state_strings;
}

void print_hash_table(const hash_table_t *hash_table)
{
    if (NULL == hash_table || NULL == hash_table->hash_data) {
        printf("hash_table or hash_table->hash_data is NULL\n");
        return;
    }

    size_t i = 0, capacity = get_hash_table_capacity(hash_table);
    for (i = 0; i < capacity; ++i) {
        printf("hash table[%zu] ===> state: %s, key: %d, value: %d\n",
                i,
                enum_state_2_strings(hash_table->hash_data[i].state),
                hash_table->hash_data[i].kv_data.key,
                hash_table->hash_data[i].kv_data.value);
    }
}

size_t hash_table_find_by_key(const hash_table_t *hash_table, key_t key)
{
    if (NULL == hash_table) {
        printf("hash_table is NULL\n");
        return (size_t)HASH_TABLE_NOT_FOUND;
    }

#ifdef USE_SQUARE_DECTIVE
    size_t start = 0, times = 1;
#endif /// USE_SQUARE_DECTIVE

    size_t index = hash_table->hash_func(key, hash_table->capacity);

    while (EMPTY_DATA != hash_table->hash_data[index].state) {
        if ((key == hash_table->hash_data[index].kv_data.key)
                && (EXIST_DATA == hash_table->hash_data[index].state)) {
            printf("same key = %d, exist data\n", key);
            return index;
        } else {
#ifndef USE_SQUARE_DECTIVE
            /* 线性探测 */
            index = linear_dective(index, hash_table->capacity);
#else
            /* 二次探测 */
            index = square_dective(start, hash_table->capacity, times);
            ++times;
#endif /// USE_SQUARE_DECTIVE
        }
    }

    printf("%s not found %d\n", __func__, key);
    return (size_t)HASH_TABLE_NOT_FOUND;
}

value_t get_value_by_key(const hash_table_t *hash_table, key_t key)
{
    value_t value = INT_MIN;
    hash_table_error_code_e ret = hash_table_find_by_key(hash_table, key);

    if ((size_t)HASH_TABLE_NOT_FOUND != ret) {
        value = hash_table->hash_data[ret].kv_data.value;
    }

    return value;
}

static hash_table_error_code_e rehash(hash_table_t *hash_table)
{
    hash_table_error_code_e ret = HASH_TABLE_OK;

    do {
        if (NULL == hash_table) {
            printf("hash_table is NULL\n");
            ret = HASH_TABLE_ERR_NULL_POINTER;
            break;
        }

        // 负载因子是 0.7
        if ((hash_table->size) * 10 / (hash_table->capacity) < 7) {
            printf("hash_table do not need rehash\n");
            break;
        }

        size_t i = 0;
        hash_table_t new_hash_table;
        size_t capacity = hash_table->capacity * 2;

        if (HASH_TABLE_OK != hash_table_init(&new_hash_table, capacity, hash_table->hash_func)) {
            printf("hash_table_init new_hash_table fail\n");
            ret = HASH_TABLE_ERR_UNKNOWN;
            break;
        }

        for (i = 0; i < hash_table->capacity; ++i) {
            // rehash 后，才会把之前 DELETED_DATA 状态的数据删除，
            // 对于 EXIST_DATA 状态的数据，需要重新赋值给新的哈希表
            if (EXIST_DATA == hash_table->hash_data[i].state) {
                if (HASH_TABLE_OK != hash_table_insert_kv_pair(&new_hash_table,
                                                               hash_table->hash_data[i].kv_data.key,
                                                               hash_table->hash_data[i].kv_data.value)) {
                    printf("hash_table_insert_kv_pair fail\n");
                    return HASH_TABLE_ERR_UNKNOWN;
                }
            }
        }

        free(hash_table->hash_data);
        hash_table->hash_data = new_hash_table.hash_data;
        hash_table->capacity = new_hash_table.capacity;
    } while (0);

    return ret;
}

hash_table_error_code_e hash_table_insert_kv_pair(hash_table_t *hash_table,
                                                  key_t key,
                                                  value_t value)
{
    hash_table_error_code_e ret = HASH_TABLE_OK;

    do {
        if (NULL == hash_table) {
            printf("hash_table is NULL\n");
            ret = HASH_TABLE_ERR_NULL_POINTER;
            break;
        }

        if (HASH_TABLE_OK != rehash(hash_table)) {
            printf("rehash fail\n");
            ret = HASH_TABLE_ERR_EXPANSION_FAILED;
            break;
        }

        size_t index = hash_table->hash_func(key, hash_table->capacity);

#ifdef USE_SQUARE_DECTIVE
        size_t times = 1, start = index;
#endif /// USE_SQUARE_DECTIVE

        while (EXIST_DATA == hash_table->hash_data[index].state) {
            // hash table 不允许插入 相同的 key
            if ((key == hash_table->hash_data[index].kv_data.key)) {
                return HASH_TABLE_NOT_FOUND;
            } else {
#ifndef USE_SQUARE_DECTIVE
                /* 线性探测 */
                index = linear_dective(index, hash_table->capacity);
#else
                /* 二次探测 */
                index = square_dective(start, hash_table->capacity, times);
                ++times;
#endif /// USE_SQUARE_DECTIVE
            }
        }

        hash_table->hash_data[index].kv_data.key = key;
        hash_table->hash_data[index].kv_data.value = value;
        hash_table->hash_data[index].state = EXIST_DATA;
        ++hash_table->size;
    } while (0);

    return ret;
}

hash_table_error_code_e hash_table_remove_by_key(hash_table_t *hash_table, key_t key)
{
    if (NULL == hash_table) {
        printf("hash_table is NULL\n");
        return HASH_TABLE_ERR_NULL_POINTER;
    }

    size_t index = hash_table->hash_func(key, hash_table->capacity);

#ifdef USE_SQUARE_DECTIVE
    size_t times = 1, start = index;
#endif /// USE_SQUARE_DECTIVE

    while (EMPTY_DATA != hash_table->hash_data[index].state) {
        if ((key == hash_table->hash_data[index].kv_data.key)
                && (EXIST_DATA == hash_table->hash_data[index].state)) {
            hash_table->hash_data[index].state = DELETED_DATA;
            --hash_table->size;
            return HASH_TABLE_OK;
        } else {
#ifndef USE_SQUARE_DECTIVE
            /* 线性探测 */
            index = linear_dective(index, hash_table->capacity);
#else
            /* 二次探测 */
            index = square_dective(start, hash_table->capacity, times);
            ++times;
#endif /// USE_SQUARE_DECTIVE
        }
    }

    return HASH_TABLE_NOT_FOUND;
}

void hash_table_destroy(hash_table_t *hash_table)
{
    if (NULL == hash_table) {
        printf("hash_table is NULL\n");
        return;
    }

    free(hash_table->hash_data);
    hash_table->hash_data = NULL;
    hash_table->capacity = 0;
    hash_table->size = 0;
}

1.4 test_hash_table.c

#include "hash_table.h"

#include <time.h>

void test()
{
    srand((unsigned int)time(NULL));

    int i = 0;
    hash_table_t hash_table;

#ifndef USE_SQUARE_DECTIVE
    /* 测试线性探测法 */
    int numbers[] = {1, 19, 38, 27, 19, 30, 20, 73, 126, 13};
#else
    /* 测试二次探测法 */
    int numbers[] = {0, 11, 22, 33, 44};
#endif /// USE_SQUARE_DECTIVE

    printf("hash table init\n");
    if (HASH_TABLE_OK != hash_table_init(&hash_table,
                                         sizeof(numbers) / sizeof(int),
                                         mod_func)) {
        printf("hash_table_init fail\n");
        return;
    }

    printf("\nprint hash_table\n");
    print_hash_table(&hash_table);
    printf("hash table capacity: %zu\n", get_hash_table_capacity(&hash_table));
    printf("hash table size: %zu\n", get_hash_table_size(&hash_table));

    for (i = 0; i < sizeof(numbers) / sizeof(int); ++i) {
        size_t index = hash_table_find_by_key(&hash_table, numbers[i]);
        printf("index: %zu, numbers[%d]: %d\n", index, i, numbers[i]);

        if ((size_t)HASH_TABLE_NOT_FOUND == index) {
            int random_num = rand() % 100 + 1;
            printf("random num: %d\n", random_num);
            if (HASH_TABLE_OK != hash_table_insert_kv_pair(&hash_table,
                                                           numbers[i],
                                                           random_num)) {
                printf("hash_table_insert_kv_pair failed, key: %d, value: %d\n",
                        numbers[i], random_num);
            }
        }
    }

#ifndef USE_SQUARE_DECTIVE
    printf("\nhash_table[%d]: %d\n", 1, get_value_by_key(&hash_table, 1));
    printf("\nhash_table[%d]: %d\n", 19, get_value_by_key(&hash_table, 19));
    printf("hash_table[%d]: %d\n", 72, get_value_by_key(&hash_table, 72));
    printf("hash_table[%d]: %d\n", 33, get_value_by_key(&hash_table, 33));
#else
    printf("\nhash_table[%d]: %d\n", 11, get_value_by_key(&hash_table, 11));
    printf("\nhash_table[%d]: %d\n", 33, get_value_by_key(&hash_table, 33));
    printf("hash_table[%d]: %d\n", 15, get_value_by_key(&hash_table, 15));
#endif /// USE_SQUARE_DECTIVE

    printf("\nprint hash_table\n");
    print_hash_table(&hash_table);
    printf("hash table capacity: %zu\n", get_hash_table_capacity(&hash_table));
    printf("hash table size: %zu\n", get_hash_table_size(&hash_table));

    if (HASH_TABLE_OK != hash_table_remove_by_key(&hash_table, 45)) {
        printf("hash_table_remove_by_key failed, key: %d\n", 45);
    }
    printf("\nprint hash_table\n");
    print_hash_table(&hash_table);

#ifndef USE_SQUARE_DECTIVE
    if (HASH_TABLE_OK != hash_table_remove_by_key(&hash_table, 19)) {
        printf("hash_table_remove_by_key failed, key: %d\n", 19);
    }
#else
    if (HASH_TABLE_OK != hash_table_remove_by_key(&hash_table, 44)) {
        printf("hash_table_remove_by_key failed, key: %d\n", 44);
    }
#endif /// USE_SQUARE_DECTIVE
    printf("\nprint hash_table\n");
    print_hash_table(&hash_table);

    if (HASH_TABLE_OK != hash_table_insert_kv_pair(&hash_table, 179, 666)) {
        printf("hash_table_insert_kv_pair failed, key: %d, value: %d\n", 179, 666);
    }
    printf("\nprint hash_table\n");
    print_hash_table(&hash_table);

    printf("\nhash_table[%d]: %d\n", 179, get_value_by_key(&hash_table, 179));

    printf("\nhash table destroy\n");
    hash_table_destroy(&hash_table);

    printf("hash table capacity: %zu\n", get_hash_table_capacity(&hash_table));
    printf("hash table size: %zu\n", get_hash_table_size(&hash_table));
}

int main(void)
{
    test();

    return 0;
}

2. 哈希桶

2.1 Makefile

.PHONY: clean

CC = gcc
CFLAGS = -g -Wall -DDEBUG

# match *.c
SOURCE = $(wildcard ./*.c)
# replace * with *.c
BIN = $(patsubst %.c, %, $(notdir $(SOURCE)))

$(BIN): $(SOURCE)
	$(CC) $(CFLAGS) $(SOURCE) -o $@

clean:
	rm -rf $(BIN)

2.2 hash_bucket.h

#ifndef __HASH_BUCKET_H__
#define __HASH_BUCKET_H__

#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <limits.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef int key_t;
typedef int value_t;

typedef struct {
    key_t key;
    value_t value;
} kv_pair_t;

typedef enum {
    HASH_BUCKET_OK                               = 0,
    HASH_BUCKET_NOT_FOUND                        = -0x0001,
    HASH_BUCKET_ERR_NULL_POINTER                 = -0x0002,
    HASH_BUCKET_ERR_CREATE_HEAP_FAILED           = -0x0003,
    HASH_BUCKET_NO_CAPACITY                      = -0x0004
} hash_bucket_error_code_e;

// 哈希桶里每个数据的类型
typedef struct hash_data_s {
    kv_pair_t kv_data;
    struct hash_data_s *next;
} hash_data_t;

typedef size_t (*hash_func_handler)(key_t, size_t);

// 哈希桶
typedef struct {
    hash_data_t **hash_data; // 实际存储空间, 即 指针数组
    size_t capacity; // 容量
    size_t size; // 实际已存储的数据个数
    hash_func_handler hash_func; // 哈希函数
} hash_bucket_t;

// 取模函数
size_t mod_func(key_t key, size_t capacity);
// 哈希桶的初始化
hash_bucket_error_code_e hash_bucket_init(hash_bucket_t *hash_bucket,
                                          size_t capacity,
                                          hash_func_handler hash_func);

size_t get_hash_bucket_capacity(const hash_bucket_t *hash_bucket);

size_t get_hash_bucket_size(const hash_bucket_t *hash_bucket);

void print_hash_bucket(const hash_bucket_t *hash_bucket);
// 哈希桶的查找，如果找到了则返回头指针，没找到的话返回 NULL
hash_data_t *hash_bucket_find_by_key(const hash_bucket_t *hash_bucket, key_t key);

value_t get_value_by_key(const hash_bucket_t *hash_bucket, key_t key);

hash_bucket_error_code_e hash_bucket_insert_kv_pair(hash_bucket_t *hash_bucket,
                                                    key_t key,
                                                    value_t value);

hash_bucket_error_code_e hash_bucket_remove_by_key(hash_bucket_t *hash_bucket, key_t key);

void hash_bucket_destroy(hash_bucket_t *hash_bucket);

#ifdef __cplusplus
}
#endif

#endif // __HASH_BUCKET_H__

2.3 hash_bucket.c

#include "hash_bucket.h"

static size_t get_next_prime_number(size_t num)
{
    size_t i = 0;
    static const size_t prime_list[] = {
        53ul, 97ul, 193ul, 389ul, 769ul,
        1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
        49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
        1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
        50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
        1610612741ul, 3221225473ul, 4294967291ul
    };

    for (i = 0; i < sizeof(prime_list) / sizeof(size_t); ++i) {
        if (prime_list[i] >= num) {
            return prime_list[i];
        }
    }

    return (size_t)-1;
}

size_t mod_func(key_t key, size_t capacity)
{
    return (size_t)key % capacity;
}

hash_bucket_error_code_e hash_bucket_init(hash_bucket_t *hash_bucket,
                                          size_t capacity,
                                          hash_func_handler hash_func)
{
    hash_bucket_error_code_e ret = HASH_BUCKET_OK;
    size_t i = 0;

    do {
        if (NULL == hash_bucket) {
            printf("hash_bucket is NULL\n");
            ret = HASH_BUCKET_ERR_NULL_POINTER;
            break;
        }

        capacity = get_next_prime_number(capacity);
        if ((size_t)-1 == capacity) {
            printf("get_next_prime_number fail\n");
            ret = HASH_BUCKET_NO_CAPACITY;
            break;
        }

        hash_bucket->hash_data = (hash_data_t **)calloc(1, sizeof(hash_data_t *) * capacity);
        if (NULL == hash_bucket->hash_data) {
            perror("calloc hash_bucket->hash_data fail");
            ret = HASH_BUCKET_ERR_CREATE_HEAP_FAILED;
            break;
        }

        hash_bucket->size = 0;
        hash_bucket->capacity = capacity;
        hash_bucket->hash_func = hash_func;

        for (i = 0; i < capacity; ++i) {
            // 存放头指针
            hash_bucket->hash_data[i] = NULL;
        }

    } while (0);

    return ret;
}

size_t get_hash_bucket_capacity(const hash_bucket_t *hash_bucket)
{
    return hash_bucket ? hash_bucket->capacity : 0;
}

size_t get_hash_bucket_size(const hash_bucket_t *hash_bucket)
{
    return hash_bucket ? hash_bucket->size : 0;
}

void print_hash_bucket(const hash_bucket_t *hash_bucket)
{
    if (NULL == hash_bucket || NULL == hash_bucket->hash_data) {
        printf("hash_bucket or hash_bucket->hash_data is NULL\n");
        return;
    }

    size_t i = 0, capacity = get_hash_bucket_capacity(hash_bucket);
    hash_data_t *cur = NULL;

    for (i = 0; i < capacity; ++i) {
        printf("hash bucket[%zu] -> ", i);

        for (cur = hash_bucket->hash_data[i]; NULL != cur; cur = cur->next) {
            printf("{%d : %d} -> ", cur->kv_data.key, cur->kv_data.value);
        }

        printf("NULL\n");
    }
}

hash_data_t *hash_bucket_find_by_key(const hash_bucket_t *hash_bucket, key_t key)
{
    hash_data_t *cur = NULL;

    if (NULL == hash_bucket) {
        printf("hash_bucket is NULL\n");
        return NULL;
    }

    size_t index = hash_bucket->hash_func(key, hash_bucket->capacity);
    for (cur = hash_bucket->hash_data[index]; NULL != cur; cur = cur->next) {
        if (key == cur->kv_data.key) {
            return cur;
        }
    }

    printf("not found %d\n", key);
    return NULL;
}

value_t get_value_by_key(const hash_bucket_t *hash_bucket, key_t key)
{
    value_t value = INT_MIN;
    hash_data_t *found = hash_bucket_find_by_key(hash_bucket, key);

    if (NULL != found) {
        return found->kv_data.value;
    }

    return value;
}

hash_bucket_error_code_e hash_bucket_insert_kv_pair(hash_bucket_t *hash_bucket,
                                                    key_t key,
                                                    value_t value)
{
    hash_bucket_error_code_e ret = HASH_BUCKET_OK;

    do {
        if (NULL == hash_bucket) {
            printf("hash_bucket is NULL\n");
            ret = HASH_BUCKET_ERR_NULL_POINTER;
            break;
        }

        size_t index = hash_bucket->hash_func(key, hash_bucket->capacity);
        hash_data_t *cur = NULL, *new_hash_data = NULL;

        for (cur = hash_bucket->hash_data[index]; NULL != cur; cur = cur->next) {
            if (key == cur->kv_data.key) {
                return HASH_BUCKET_NOT_FOUND;
            }
        }

        new_hash_data = (hash_data_t *)calloc(1, sizeof(hash_data_t));
        if (NULL == new_hash_data) {
            perror("calloc new_hash_data fail");
            ret = HASH_BUCKET_ERR_CREATE_HEAP_FAILED;
            break;
        }

        new_hash_data->kv_data.key = key;
        new_hash_data->kv_data.value = value;
        ++hash_bucket->size;

        // 头插
        new_hash_data->next = hash_bucket->hash_data[index];
        hash_bucket->hash_data[index] = new_hash_data;
    } while (0);

    return ret;
}

hash_bucket_error_code_e hash_bucket_remove_by_key(hash_bucket_t *hash_bucket, key_t key)
{
    if (NULL == hash_bucket) {
        printf("hash_bucket is NULL\n");
        return HASH_BUCKET_ERR_NULL_POINTER;
    }

    size_t index = hash_bucket->hash_func(key, hash_bucket->capacity);
    hash_data_t *cur = NULL, *tmp_hash_data = NULL, *next_hash_data = NULL;

    for (cur = hash_bucket->hash_data[index]; NULL != cur; cur = next_hash_data) {
        next_hash_data = cur->next;

        if (key == cur->kv_data.key) {
            if (NULL == tmp_hash_data) {
                // 头删
                hash_bucket->hash_data[index] = next_hash_data;
            } else {
                tmp_hash_data->next = next_hash_data;
            }

            free(cur);
            --hash_bucket->size;
            return HASH_BUCKET_OK;
        } else {
            tmp_hash_data = cur;
        }
    }

    return HASH_BUCKET_NOT_FOUND;
}

void hash_bucket_destroy(hash_bucket_t *hash_bucket)
{
    if (NULL == hash_bucket) {
        printf("hash_bucket is NULL\n");
        return;
    }

    size_t i = 0;
    hash_data_t *cur = NULL, *next_data = NULL;

    for (i = 0; i < hash_bucket->capacity; ++i) {
        for (cur = hash_bucket->hash_data[i]; NULL != cur; cur = next_data) {
            next_data = cur->next;
            free(cur);
        }
    }

    free(hash_bucket->hash_data);
    hash_bucket->hash_data = NULL;
    hash_bucket->capacity = 0;
    hash_bucket->size = 0;
}

2.4 test_hash_bucket.c

#include "hash_bucket.h"

#include <time.h>

void test()
{
    hash_bucket_t hash_bucket;
    size_t i = 0;
    hash_data_t *found = NULL;
    int numbers[] = {1, 23, 46, 53, 106, 34, 11, 2, 34, 55};

    srand((unsigned int)time(NULL));

    printf("hash bucket init\n");
    if (HASH_BUCKET_OK != hash_bucket_init(&hash_bucket,
                                           sizeof(numbers) / sizeof(int),
                                           mod_func)) {
        printf("hash_bucket_init fail\n");
        return;
    }

    printf("\nprint hash_bucket\n");
    print_hash_bucket(&hash_bucket);
    printf("hash table capacity: %zu\n", get_hash_bucket_capacity(&hash_bucket));
    printf("hash table size: %zu\n", get_hash_bucket_size(&hash_bucket));

    for (i = 0; i < sizeof(numbers) / sizeof(int); ++i) {
        found = hash_bucket_find_by_key(&hash_bucket, numbers[i]);

        if (NULL == found) {
            int random_num = rand() % 100 + 1;
            printf("random num: %d\n", random_num);

            if (HASH_BUCKET_OK != hash_bucket_insert_kv_pair(&hash_bucket,
                                                             numbers[i],
                                                             random_num)) {
                printf("hash_bucket_insert_kv_pair failed, key: %d, value: %d\n",
                        numbers[i], random_num);
            }
        }
    }

    printf("\nhash_bucket[%d]: %d\n", 55, get_value_by_key(&hash_bucket, 55));
    printf("hash_bucket[%d]: %d\n", 33, get_value_by_key(&hash_bucket, 33));

    printf("\nprint hash_bucket\n");
    print_hash_bucket(&hash_bucket);
    printf("hash table capacity: %zu\n", get_hash_bucket_capacity(&hash_bucket));
    printf("hash table size: %zu\n", get_hash_bucket_size(&hash_bucket));

    printf("\nhash_bucket_remove_by_key\n");
    if (HASH_BUCKET_OK != hash_bucket_remove_by_key(&hash_bucket, 1)) {
        printf("hash_bucket_remove_by_key failed, key: %d\n", 1);
    }

    if (HASH_BUCKET_OK != hash_bucket_remove_by_key(&hash_bucket, 106)) {
        printf("hash_bucket_remove_by_key failed, key: %d\n", 106);
    }

    printf("\nprint hash_bucket\n");
    print_hash_bucket(&hash_bucket);
    printf("hash table capacity: %zu\n", get_hash_bucket_capacity(&hash_bucket));
    printf("hash table size: %zu\n", get_hash_bucket_size(&hash_bucket));

    printf("\nhash bucket destroy\n");
    hash_bucket_destroy(&hash_bucket);

    printf("hash table capacity: %zu\n", get_hash_bucket_capacity(&hash_bucket));
    printf("hash table size: %zu\n", get_hash_bucket_size(&hash_bucket));
}

int main(void)
{
    test();

    return 0;
}
sustzc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——哈希
Benson的博客
02-03 415
哈希       像C++和Java这种高级语言，都提供了哈希(Hash)的集合库。Hash也是一种数据结构，这种数据结构的特点就是可以储存键值对，每个键都对应着一个值，可以通过键在Hash表中快速查找到这个键所对应的值。Hash表会预先申请一块比较大的内存，当向Hash表中添加键值对时，就直接存入在已经申请的内存中。通常，Hash需要一个Hash函数来确定这个值应该存放在哪里，因为在Hash表
数据结构之哈希
猝然临之而不惊，无故加之而不怒
04-09 279
什么是哈希表 哈希表就是一种以 键-值(key-indexed) 存储数据的结构，我们只要输入待查找的值即key，即可查找到其对应的值。 哈希的思路很简单，如果所有的键都是整数，那么就可以使用一个简单的无序数组来实现：将键作为索引，值即为其对应的值，这样就可以快速访问任意键的值。这是对于简单的键的情况，我们将其扩展到可以处理更加复杂的类型的键。 使用哈希查找有两个步骤: 使用哈希函数将被查...
数据结构哈希查找的C语言实现
weixin_65155181的博客
08-03 2304
大家好，我是练习编程时长两年半的昆工第一ikun，今天我们来分享查找算法中的一个——哈希查找，哈希查找适用于有庞大的数据量时的查找，是一种很好用的查找算法，话不多说，开团！！！
数据结构哈希表的建立和查找数据
weixin_45646601的博客
04-06 1966
#include <stdio.h> #include <string.h> #include <stdlib.h> #include <conio.h> #define NUM 5 typedef struct hash { int num;//哈希表多少个值 char* data;//data的指针 }hash; hash* init() { hash* L = (hash*)malloc(sizeof(hash)); L->num = 0.
数据结构哈希查找
06-01
散列技术是在记录的存储位置和它的关键字之间建立一个确定的对应关系f，使得每个关键字key对应一个存储位置f(key)。建立了关键字与存储位置的映射关系，
数据结构哈希表设计(1).doc
07-11
在这个数据结构哈希表设计的问题中，我们主要关注以下几个知识点： 1. **哈希表**：哈希表是一种数据结构，它使用哈希函数将数据映射到一个固定大小的数组中，以便快速查找。在这个任务中，哈希表用于存储30个人的...
数据结构 哈希搜索结构
01-06
我们之前学过的查找方法有很多： 1.静态搜索 顺序查找：O(N)。 二分查找：O(logN)。 2.动态搜索 二叉搜索树：最优查询效率O(N)。 AVL树：O(logN)。...但是上述的查找都是要经过元素比较...这种方式的结构就是哈希搜索结
数据结构哈希表算法实现
01-26
/******************* 数据结构哈希表算法实现 ********************/
数据结构哈希表的应于电话本的制作
08-29
数据结构哈希表的应于电话本的制作
【数据结构】—— 树和二叉树
mist的博客
08-26 1461
树和二叉树、堆（顺序结构）、二叉树链式结构
数据结构：用栈实现队列（232）LeetCode
2303_81073778的博客
08-26 787
你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）
数据结构-时间、空间复杂度-详解
2401_86587256的博客
08-23 1631
数据结构-时间、空间复杂度-详解
浅谈【数据结构】树与二叉树之哈夫曼树
weixin_67526434的博客
08-26 986
浅谈【数据结构】树与二叉树之哈夫曼树
【数据结构】-----哈希
最新发布
m0_73470633的博客
08-29 632
一文看懂哈希结构！
数据结构（邓俊辉）学习笔记】串 05——KMP算法：理解next[]表
weixin_44399845的博客
08-26 1207
KMP算法：理解next[]表
集合及数据结构第十二节（下）————哈希表、字符串常量池和练习题
2301_79418684的博客
08-26 895
哈希表、字符串常量池和练习题 1. 哈希表的概念 2. 冲突-概念 3. 冲突-避免 4. 冲突-解决 5. 冲突严重时的解决办法 6. 冲突严重时的解决办法的实现 7. 性能分析 8. 和 java 类集的关系 9. Hashmap的使用案例 10. 模拟实现HashMap（k-v模型） 11. 创建对象的思考 12. 字符串常量池(StringTable) 13. 再谈String对象创建 14. 练习
【JAVA】后端开发中的数据结构：基础知识与应用场景
一个不断前行的程序者
08-25 1097
*数据结构是后端开发中的基础和核心。**通过了解数据结构的基本概念、常见类型以及在日常开发中的应用场景，我们可以更好地运用数据结构来提高程序的性能和可维护性。在后端开发中，掌握数据结构对于提升个人技能和职业发展具有重要意义。在实际工作中，我们应该根据具体需求和场景选择合适的数据结构，以实现高效、稳定的系统设计。
浅谈【数据结构】树与二叉树之平衡二叉树
weixin_67526434的博客
08-26 335
浅谈【数据结构】树与二叉树之平衡二叉树
数据结构哈希查找C语言
07-17
这样，我们就可以使用哈希查找来快速检索数据了。注意，在实际应用中，还需要处理哈希冲突的情况，例如使用链地址法解决冲突。另外，还需要实现删除操作等其他功能。以上只是一个简单的哈希查找的示例。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值