C语言哈希表的简单实现——数组+链表（拉链法）

C语言哈希表的简单实现——数组+链表（拉链法）

1.哈希表简介

哈希表详细介绍可以参考这篇文章

2.哈希表拉链法实现

2.1完全由本人思路实现，如有错误，欢迎批评指正

哈希声明文件hash.h

/* 哈希表
*  by  : I'M渣渣
*  date: 2021.5.11
*/

#ifndef __HASH_H_
#define __HASH_H_

#define size 100  //哈希数组大小为100
#include <stdbool.h> //C语言使用bool类型需要调用的头文件
#include <stdio.h>
#include <stdlib.h>

//创建哈希结构体
typedef struct hash_value_{
    int _int_key;
    double _double_key;
    float _float_key;
    char _char_key;
    char *_str_key;

    int _int;
    double _double;
    float _float;
    char _char;
    char *_str;

    struct hash_value_ * _hash_value_next;
}hash_value;
//创建hash_value指针数组
hash_value *hash_arry[size];

void hash_default(hash_value *hash_arry_[]); //哈希数组初始化
int hash_int(int key); 
int hash_double(double key);          //哈希函数
int hash_float(float key);
int hash_char(char key);
int hash_charstr(char *key);
bool add_mod_key_value_int(int key,int value); //添加与修改 <int key,int value>
int get_key_value_int(int key); //获取value <int key>
bool add_mod_key_value_charstr_int(char *key,int value);//添加与修改 <str key,int value>
int get_key_value_charstr_int(char *key);//获取value <str value>
#endif // !__HASH_H_

哈希实现hash.c

/* 哈希表
*  by  : I'M渣渣
*  date: 2021.5.11
*/
#include "hash.h"
#include "string.h"

//初始化指针数组，全部赋值为空
void hash_default(hash_value *hash_arry_[]){
    for(int i=0;i<size;++i){
        hash_arry_[i]=NULL;
    }
}

//创建哈希函数,返回哈希值
int hash_int(int key){
    return key%size;
}
int hash_double(double key){
    return (int)key%size;
}
int hash_float(float key){
    return (int)key%size;
}
int hash_char(char key){
    return (int)key%size;
}
int hash_charstr(char *key){
    int x=0;
    int i=0;
    while(*(key+i)!='\0'){
        x=x+(int)(*key);
        i++;
    }
    return x%size;
}

//添加操作
bool add_mod_key_value_int(int key,int value){
    hash_value *head=hash_arry[hash_int(key)];
    hash_value *p=NULL;
    while(head){
        if(key==head->_int_key){
            head->_int=value;
            break;
        }
        if(head->_hash_value_next==NULL) break; 
        if(key>head->_int_key&&key<head->_hash_value_next->_int_key) break;
        
        head=head->_hash_value_next;
    }
    
    hash_value *V=(hash_value *)malloc(sizeof(hash_value));
    if(head==NULL) {
        V->_int_key           = key;
        V->_int               = value;
        V->_hash_value_next   = NULL;//这里为初始指针赋值，初始数组里初始为NULL，不能用head
        hash_arry[hash_int(key)]=V;
    }
    else {
        V->_int_key           = key;
        V->_int               = value;
        
        p                     = head->_hash_value_next;
        head->_hash_value_next= V;
        V->_hash_value_next   = p;  
        
    } 
    return true;
}
//获取value值
int get_key_value_int(int key){
    int *x;
    x=(int *)malloc(2*sizeof(int));
    hash_value *head=hash_arry[hash_int(key)];
    while(head){
        if(key==head->_int_key){
            return head->_int;
        } 
        if(key>head->_int_key&&key<head->_hash_value_next->_int_key){
            return -1;
        }
        head=head->_hash_value_next;
    }
    return -1;
}

bool add_mod_key_value_charstr_int(char *key,int value){
    hash_value *head=hash_arry[hash_charstr(key)];
    hash_value *p=NULL;
    while(head){
        if(strcmp(key,head->_str_key)){
            head->_int=value;
            break;
        }
        if(head->_hash_value_next==NULL) break; 
        
        
        head=head->_hash_value_next;
    }
    
    hash_value *V=(hash_value *)malloc(sizeof(hash_value));
    if(head==NULL) {
        V->_str_key           = key;
        V->_int               = value;
        V->_hash_value_next   = NULL;
        hash_arry[hash_charstr(key)]=V;
    }
    else {
        V->_str_key           = key;
        V->_int               = value;
        
        p                     = head->_hash_value_next;
        head->_hash_value_next= V;
        V->_hash_value_next   = p;  
        
    } 
    return true;
}
int get_key_value_charstr_int(char *key){
    int *x;
    x=(int *)malloc(2*sizeof(int));
    hash_value *head=hash_arry[hash_charstr(key)];
    while(head){
        if(strcmp(key,head->_str_key)==0){
            return head->_int;
        }
        head=head->_hash_value_next;
    }
    return -1;
}

测试文件main.c

/* 哈希表
*  by  : I'M渣渣
*  date: 2021.5.11
*/
#include "hash.h"
#include "stdio.h"

int main(int argc,char *argv[]){
    int arry_key[10000];
    int arry[10000];    
    char *arrystr[10]={//字符串一定要用，号隔开
        "agcdef",
        "dasdawenei",
        "liasdawxuan",
        "apple",
        "yiyaasdwen",
        "asdwert",
        "laasdnshasdu",
        "chenchegfhfghng",
        "qwe",
        "rrrr",
    };
    int arrystrint[10];
    hash_default(hash_arry);
    printf("**********\n");
    /*for(int i=0;i<10000;++i){
        arry_key[i]=i;
        arry[i]=i;
        add_mod_key_value_int(arry_key[i],arry[i]);
    }
    
    
    while (1)
    {
        int x;
        scanf("%d",&x);
        printf("key:%d,value:%d\n",x,get_key_value_int(x));
    }*/
    printf("**********\n");
    for(int i=0;i<10;++i){
        arrystrint[i]=i;
        //printf("\n%s",*(arrystr+i));
        add_mod_key_value_charstr_int(*(arrystr+i),arrystrint[i]);
        //printf("&&&\n");
    }
    printf("**********\n");
    while (1)
    {
        char x[1024];//字符串键入要有一定的内存大小，不能char *x
        scanf("%s",x);
        //printf("%s",x);
        printf("key:%s,value:%d\n",x,get_key_value_charstr_int(x));
    }

    return 0;
}