精华内容
下载资源
问答
  • c语言实现哈希表
    2021-05-26 02:52:00

    #include

    #define HASHSIZE 101

    struct nlist { /*table entry*/

    struct nlist *next; /*next entry in chain */

    char *name; /* defined name */

    char *defn; /* replacement text */

    };

    static struct nlist *hashtable[HASHSIZE]; /* pointer table */

    /************************************************************************/

    /* hash : form hash value for string s

    /************************************************************************/

    unsigned hash( char *s ){

    unsigned hashval;

    for (hashval = 0; *s != '\0' ; s ++) {

    hashval = *s + 31 * hashval;

    }

    return hashval % HASHSIZE;

    }

    /************************************************************************/

    /* lookup : look for s in hashtab

    /************************************************************************/

    struct nlist *lookup(char *s){

    struct nlist *np;

    for (np = hashtable[hash(s)]; np != NULL; np = np->next) {

    if (strcmp(s, np->name) == 0)

    {

    return np;/* found */

    }

    }

    return NULL;

    }

    char *strdup(char *);

    /************************************************************************/

    /* install : put (name, defn ) in hashtable

    /************************************************************************/

    struct nlist *install(char *name, char *defn){

    struct nlist *np;

    unsigned hashval;

    if ((np = lookup(name)) == NULL) {/* not found*/

    np = (struct nlist *)malloc(sizeof(struct nlist));

    if (np == NULL || (np->name = strdup(name) ) == NULL) {

    return NULL;

    }

    hashval = hash(name);

    np->next = hashtable[hashval];

    hashtable[hashval] = np;

    }else{

    free((void*)np->defn);

    }

    if ((np->defn = strdup(defn)) == NULL) {

    return NULL;

    }

    return np;

    };

    void printNode(struct nlist *np){

    if (np != NULL) {

    printf("#define %s %s\t", np->name, np->defn);

    printNode(np->next);

    }

    }

    void print(){

    int i = 0;

    for(; i < HASHSIZE; i ++){

    printNode(hashtable[i]);

    printf("\n");

    }

    }

    int main(){

    install("a", "1");

    print();

    return 0;

    }

    更多相关内容
  • C语言实现哈希表

    千次阅读 2021-05-17 11:06:30
    C语言实现哈希表 简介:遇到散列表冲突时,采用链表分离的方式 哈希表在根据内容查找时,它的时间复杂度相对于要逐一遍历的数组或者链表要小。 散列算法:主要由md5(消息摘要算法),sha1(安全散列) ,这两者不可靠。...

    C语言实现哈希表

    简介:
    哈希表在根据内容查找时,它的时间复杂度相对于要逐一遍历的数组或者链表要小。

    散列算法:主要由md5(消息摘要算法),sha1(安全散列) ,这两者不可靠。sha2(安全散列2 sha256/512)目前还没冲突,较为可靠。

    散列冲突:多个数据,进行散列之后的散列值相同,此时会存在散列冲突。
    常见的解决方法:有线性探测、平方探测、二次散列、链表分离、链表分离改良实现(链表+红黑树)。

    该程序:采用链表分离的方法解决散列冲突。适合初学者学习。
    哈希表
    该图为本程序的图解,结合此图看程序时有对哈希表有较好的理解。

    //sanlie.c 哈希表的实现
    //采用链表的方式
    //遇到散列冲突时,采用链表分离的方式
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    //哈希表中数据元素的结构体
    typedef struct
    {
        char *key; //关键字
        char *value;
    } Element;
    
    //数据元素单链表
    typedef struct Node
    {
        Element student;   //数据元素
        struct Node *next; //next指针
    } Node;
    
    //哈希表
    typedef struct
    {
        Node *head; //数据元素存储
        int size;   //当前表中的大小,表长
        int count;  //哈希表中的数据元素的个数
    } HashTable;
    
    //初始化哈希表
    HashTable *inittable(int tablesize)
    {
        HashTable *table = (HashTable *)malloc(sizeof(HashTable));
        table->size = tablesize;
        //分配和初始化单链表数据元素的头结点
        table->head = (Node *)malloc((table->size) * sizeof(Node));
        memset(table->head, 0, sizeof(Node) * (table->size));
        table->count = 0; //现有的元素的个数
    
        return table;
    }
    
    //哈希函数
    int hash(HashTable *table, char *key)
    {
        int sum = 0; //字符串的ASNI之和
        for (int i = 0; i < strlen(key); i++)
        {
            sum += key[i];
        }
    
        return sum % table->size;
    }
    
    //在哈希表中查找关键字
    Node *find(HashTable *table, char *key)
    {
        int ii = hash(table, key);
    
        Node *node = table->head[ii].next;
    
        //遍历单链表
        while ((node != NULL) && (node->student.key != key))
        {
            node = node->next;
        }
    
        return node;
    }
    
    //往哈希表中插入元素
    int put(HashTable *table, char *key, char *value)
    {
        //从哈希表中查找元素
        Node *ee = find(table, key);
    
        if (ee != NULL)
        {
            printf("元素已经存在。\n");
            return 0;
        }
    
        int ii = hash(table, key);
    
        Node *node = (Node *)malloc(sizeof(Node));
        node->student.key = key;
        node->student.value = value;
    
        //追加在对应位置的头结点后面
        node->next = table->head[ii].next;
        table->head[ii].next = node;
    
        table->count++;
        return 1;
    }
    
    //遍历哈希表
    void Print(HashTable *table)
    {
        for (int i = 0; i < table->size; i++)
        {
            Node *node = table->head[i].next;
    
            while (node)
            {
                printf("%s-%s  ", node->student.key, node->student.value);
                node = node->next;
            }
            printf("\n");
        }
    
        printf("\n");
    }
    
    //从哈希表中删除元素
    int get(HashTable *table, char *key)
    {
        int ii = hash(table, key);
    
        Node *node = &table->head[ii];
    
        //遍历单链表,node停留在待删除关键结点key的前一结点
        while ((node != NULL) && (node->next->student.key != key))
        {
            node = node->next;
        }
    
        if (node->next == NULL)
            return 0; //查找失败
    
        Node *tmp = node->next; //tmp为将要删除的结点
    
        node->next = tmp->next;
    
        free(tmp); //释放结点
    
        table->count--;
    
        return 1;
    }
    
    int main(int argc, char const *argv[])
    {
        HashTable *table = inittable(5);
    
        put(table, "alice", "alice info");
        put(table, "bob", "bob info");
        put(table, "hack", "hack info");
    
        Print(table);
    
        get(table, "bob");
        Print(table);
    
        Node *node = find(table, "hack");
        if (node != NULL)
            printf("找到%s-%s\n", node->student.key, node->student.value);
    
        Node *node1 = find(table, "bob");
        if (node1 != NULL)
            printf("找到%s-%s\n", node1->student.key, node1->student.value);
    
        return 0;
    }
    
    展开全文
  • c语言实现哈希表

    千次阅读 2022-03-23 21:00:27
    哈希表

    最近在做FTP服务器项目的时候,需要统计服务器的最大连接数和每IP连接数。
    每IP连接数:指的是服务器连接同一个IP地址的次数
    最大连接数:服务器最多可以连接客户端的个数
    其中前者需要用到哈希表。
    c++中,我们可以直接使用map或者unordered_map来产生pair键值对,c语言中没有对应的库,所以需要自己实现一下hash表的结构。
    如下图所示:

    1. hash表中保存的是哈希函数,桶结点的个数,以及二级指针:存储的是桶结点的地址。
    2. 每一个桶结点中存放的是哈希结点的地址,是一个一级指针,桶结点的个数为4个。
    3. 每一个hash结点是由key指针,value指针,结点的前驱指针,后继指针构成的。这里之所以存放的是指针,是因为它可以接收任意类型的数据。

    一般哈希函数选择的是除留余数法
    hash(key)=key%p,其中p≤buckets,取最接近于buckets的质数即可。
    需要注意的是,由于经过哈希函数映射之后,关键码对应的位置对应滴位置可能是相同的,因此采用开散列的方法,使用链表的结构将所有相同位置的关键码串联起来。
    如下图所示:为了方便起见,11,22,33处对应的是哈希结点的地址而不是key值。链表的插入采用的是头插,提升效率。
    例如key=0,11,22,33对应的地址都是相同的,可以采用链表的方式将其连接。
    在这里插入图片描述
    1.hash_node的结构:

    typedef struct hash_node
    {
    	void *key;
    	void *node;
    	struct hash_node* prev;
    	struct hash_node* next;
    }hash_node_t;
    

    2.hash表的结构
    //函数指针 对应的函数名是hashfunc_t:参数一个为int,一个为void。经过typedef之后,可以通过hashfunc_t来代表函数指针。

    typedef unsigned int (*hashfunc_t)(unsigned int, void*);
    
    
    struct hash
    {
    	unsigned int buckets; //对应的桶的大小
    	hashfunc_t hash_func; //保存的hash函数的地址
    	hash_node_t **nodes; //二级指针,存放桶结点的首地址
    };
    

    3.hash表的生成
    类型的重定义

    typedef struct hash hash_t; 将hash表重定义为hash_t
    

    哈希表的初始化

    hash_func是自己定义的,这里存放的是函数地址。定义的hash_func如下所示:

    unsigned int hash_func(unsigned int bucket_size, void* key)
    {
    	return (*(unsigned int*)key) % bucket_size;
    }
    

    注意,这里结点的大小是桶结点的个数乘以每一个指针的内存大小,对hash_nodes所指的内存空间进行内存的初始化,指针置为NULL。

    hash_t *hash_alloc(unsigned int buckets, hashfunc_t hash_func)
    {
    	hash_t *hash = (hash_t *)malloc(sizeof(hash_t));
    	assert(hash != NULL);
    	hash->buckets = buckets;
    	hash->hash_func = hash_func;
    	int size = buckets * sizeof(hash_node_t *);
    	hash->nodes = (hash_node_t **)malloc(size);
    	memset(hash->nodes, 0, size);
    	return hash;
    }
    

    下面部分是获取关键码对应的桶结点的位置,通过hash函数映射之后计算出对应的bucket,将对应结点的地址返回。

    hash_node_t** hash_get_bucket(hash_t* hash, void* key)
    {
    	unsigned int bucket = hash->hash_func(hash->buckets, key);
    	if (bucket >= hash->buckets)
    	{
    		fprintf(stderr, "bad bucket lookup\n");
    		exit(1);
    	}
    	return &(hash->nodes[bucket]);
    }
    

    下面部分是通过关键值key来查询对应的结点,例如我们需要查找key=22的结点,找到buckets的位置之后,链表向后遍历即可。
    之前自己理解的时侯,总觉得桶结点已经找到了,为什么还需要向后遍历呢,其实是需要的,因为当前桶的头结点存储的key值可能不是我们需要找的,比如上面的例子中,buckets[0]存储的是key=0的元素的地址。

    1. 获取当前key值对应的桶结点的地址。
    2. node指向当前的桶结点的头部,依次向后寻找,直到node指向的key值和要寻找的key值相等时,代表找到了对应的结点,因此返回该结点即可。
    3. memcmp(void * str1,void * str2,size_t n)用来对比str1和str2前n个字节大小是否相等。
    hash_node_t* hash_get_node_by_key(hash_t* hash, void* key, unsigned int key_size)
    {
    	hash_node_t** bucket = hash_get_bucket(hash, key);
    	hash_node_t* node = *bucket;
    	if (node == NULL)
    	{
    		return NULL;
    	}
    	while (node != NULL && memcmp(node->key, key, key_size) != 0)
    	{
    		node = node->next;
    	}
    	return node;
    }
    

    查询key值对应的value值

    代码如下所示:如果找到key值,就返回当前key值对应的value值。否则返回NULL

    void* hash_lookup_entry(hash_t* hash, void* key, unsigned int key_size)
    {
    	hash_node_t* node = hash_get_node_by_key(hash, key, key_size);
    	if (node == NULL)
    	{
    		return NULL;
    	}
    	return node->value;
    }
    

    向哈希表中添加结点

    需要给定key值的地址,对应的大小,value值的地址,对应的大小。

    1. 首先查找,如果已经存在相同的key值,那么程序就会报错。
    2. 其次申请新的hash结点,对前驱和后继赋空。将key和value的值拷贝到node->key和node->value中。
    3. 获取当前key值对应的bucket的地址。
    4. 如果为空,代表不存在,直接将结点插入,如果不为空,代表地址发生了冲突,因此需要将新的结点插入到头部。
      在这里插入图片描述
    void hash_add_entry(hash_t* hash, void* key, unsigned int key_size, void* value, unsigned int value_size)
    {
    	if (hash_lookup_entry(hash, key, key_size))
    	{
    		fprintf(stderr, "duplicate hash key\n");
    		return;
    	}
    	hash_node_t* node = malloc(sizeof(hash_node_t));
    	node->prev = NULL;
    	node->next = NULL;
    	node->key = malloc(key_size);
    	memcpy(node->key, key, key_size);
    	node->value = malloc(value_size);
    	memcpy(node->value, value, value_size);
    	hash_node_t** bucket = hash_get_bucket(hash, key);
    	if (*bucket == NULL)
    	{
    		*bucket = node;
    	}
    	else
    	{
    		// 将新结点插入到链表头部
    		// 当前结点的后继指向下一个结点。
    		node->next = *bucket;
    		// 
    		(*bucket)->prev = node;
    		*bucket = node;
    	}
    }
    

    释放hash表中的结点

    1. 检查key值是否存在,存在的话,释放对应的key和value。
    2. 如果被释放的结点存在前驱指针,那么前驱指针的下一个指针指向当前被释放结点的下一个结点。如果不存在前驱指针,那么说明当前指针是头结点,故找到对应的桶结点的位置,将桶结点指向当前结点的下一个结点。
    3. 当前结点下一个结点不为空,下一个结点的前驱结点指向当前结点的前驱结点。
      在这里插入图片描述
    void hash_free_entry(hash_t* hash, void* key, unsigned int key_size)
    {
    	hash_node_t* node = hash_get_node_by_key(hash, key, key_size);
    	if (node == NULL)
    	{
    		return;
    	}
    	free(node->key);
    	free(node->value);
    	if (node->prev)
    	{
    	  // 第一步
    		node->prev->next = node->next;
    	}
    	else
    	{
    		hash_node_t** bucket = hash_get_bucket(hash, key);
    		*bucket = node->next;
    	}
    	// 后继结点的前驱连接被删除结点的前驱(第二步)
    	if (node->next)
    		node->next->prev = node->prev;
    	// 释放结点
    	free(node);
    }
    

    附录:假设给定的key值不是int值,要怎么处理呢?参考了一下别人的代码:将对应的字符串转为相对应的ASII值,再进行计算即可。

    unsigned int hash_func_str(unsigned int bucket_size, char* key)
    {
    	int sum = 0;
    	char* tmp = key;
    	while (*tmp != '\0')
    	{
    		sum += *tmp;
    		tmp++;
    	}
    	return sum % bucket_size;
    }
    

    打印hash表

    1.key值为数字的时候

    void printhash(hash_t* hash1)
    {
    	hash_node_t** z = hash1->nodes;
    	int i = 0;
    	for (i = 0; i < hash1->buckets; ++i)
    	{
    		if (z[i] == NULL)
    			continue;
    		while (z[i]!= NULL)
    		{
    			printf("key:%d,value:%d\n", *(int*)(z[i]->key), *(int*)(z[i]->value));
    			z[i] = z[i]->next;
    		}
    	}
    }
    

    2.key值为字符串的时候

    void printhash(hash_t* hash1)
    {
    	hash_node_t** z = hash1->nodes;
    	int i = 0;
    	for (i = 0; i < hash1->buckets; ++i)
    	{
    		if (z[i] == NULL)
    			continue;
    		while (z[i]!= NULL)
    		{
    			printf("key:%s,value:%d\n", (char*)z[i]->key, *(int*)(z[i]->value));
    			z[i] = z[i]->next;
    		}
    	}
    }
    

    测试函数如下所示:

    static struct hash* ip_count_hash;
    int main()
    {
    	ip_count_hash = hash_alloc(17, hash_func_str);
    	char key1[] = "ab";
    	//printf("%d\n", sizeof(key1));
    	int value1 = 100;
    	char key2[] = "bc";
    	int value2 = 20;
    	char key3[] = "cde";
    	int value3 = 30;
    	hash_add_entry(ip_count_hash, &key1, sizeof(key1), &value1,sizeof(int));
    	hash_add_entry(ip_count_hash, &key2, sizeof(key2), &value2, sizeof(int));
    	hash_add_entry(ip_count_hash, &key3, sizeof(key3), &value3, sizeof(int));
    	printhash(ip_count_hash);
    	return 0;
    }
    

    后续再研究闭散列吧,c语言和c++的实现差距还是挺大的,本篇主要是为了FTP服务器的IP数目限制所写的,比较简单一点,有兴趣的同学可以参考一下这篇博客哦
    FTP项目第三部分
    在这里插入图片描述

    展开全文
  • 本文为大家分享了C语言基于哈希表实现通讯录的具体代码,供大家参考,具体内容如下 1.需求分析 本演示程序用C语言编写,完成哈希表的生成,电话号码的插入、以及查找等功能。  (1)按提示输入相应的联系人的相关...
  • C语言设计哈希表实现图书查找系统,完成相应的建表和查表程序。从键盘输入各图书相关信息,分别以图书编号为关键字建立散列表。待填入哈希表的书号至少30个;构造合适的哈希函数。 1) 记录由外部输入。 2) 将生成...
  • 定义结构体 #define ElemType int #define P 7 typedef struct HashNode{ ElemType data; HashNode* link; }HashNode; ...typedef HashNode* ...实现方法 #include "HashTable.h" /* *初始化 */ void InitHashTable

    定义结构体

    #define ElemType int
    #define P 7
    typedef struct HashNode{
    	ElemType data;
    	HashNode* link;
    }HashNode;
    
    typedef HashNode* HashTable[P];//表里存的是个地址,这是个HashNode*类型的数组
    //如HashTable[i] 表示指向第一个结点的地址
    

    实现方法

    #include "HashTable.h"
    /*
    *初始化
    */
    void InitHashTable(HashTable &ht) {
    	for (int i = 0; i <P; i++){
    		ht[i] = NULL;
    	}
    }
    
    /*
    *插入
    */
    void InsertHashTable(HashTable &ht, ElemType x) {
    	int index = Hash(x);
    
    	HashNode* s = (HashNode*)malloc(sizeof(HashNode));
    	s->data = x;
    
    	//头插法
    	s->link = ht[index];//数组里存的是原来结点的地址
    	ht[index] = s;
    }
    
    /*
    *打印输出
    */
    void ShowHashTable(HashTable &ht) {
    	for (int i = 0; i < P; i++) {
    		printf("%d: ", i);
    		HashNode* p = ht[i];
    		while (p != NULL) {
    			printf("%d-->", p->data);
    			p = p->link;
    		}
    		printf(".\n");
    	}
    }
    
    /*
    *查找结点
    */
    HashNode* Search(HashTable &ht, ElemType key) {
    	int index = Hash(key);
    	HashNode* p = ht[index];
    	while (p != NULL && p->data != key) {
    		p = p->link;
    	}
    	return p;
    }
    
    /*
    *删除结点
    */
    bool RemoveHashTable(HashTable &ht, ElemType key) {
    	HashNode* p = Search(ht,key);//找到删除元素的地址
    
    	if (p == NULL) return 0;
    
    	int index = Hash(key);
    	HashNode *q = ht[index];//q指向数组元素存的地址
    	if (q == p) {//正好是数组元素存的地址
    		ht[index] = p->link;
    		free(p);
    		return 1;
    	}else{
    		while (q->link != p) {//遍历链表,找到被删除元素的前一个结点
    			q = q->link;
    		}
    		q->link = p->link;
    		free(p);
    		return 1;
    	}
    
    	return 0;
    }
    
    /*
    *构造哈希函数
    */
    int Hash(ElemType key) {
    	return key % P;
    }
    

    测试

    #include "HashTable.h"
    void main() {
    	HashTable ht;
    	InitHashTable(ht);
    	//int array[] = { 15,14,21,87,96,293,35,24,149,19,63,16,103,77,5,153,145,356,51,68,705,453 };
    	int array[] = {1,8,15,22,29,36,43,44,17,28};
    	for (int i = 0; i < sizeof(array) / sizeof(int); i++)
    	{
    		InsertHashTable(ht,array[i]);
    	}
    	ShowHashTable(ht);
    	HashNode* find=Search(ht,8);
    	
    	printf("-------------删除后------------------------");
    	printf("\n");
    	RemoveHashTable(ht, 22);
    	ShowHashTable(ht);
    }
    

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • NULL 博文链接:https://touch-2011.iteye.com/blog/1090305
  • 哈希表的建立与运用C语言实现哈希表的建立与运用C语言实现哈希表的建立与运用C语言实现哈希表的建立与运用C语言实现哈希表的建立与运用C语言实现
  • C语言基于哈希表的电话簿
  • C语言实现哈希表(链式法)

    千次阅读 多人点赞 2019-11-23 13:13:03
    笔者最近学习数据结构中的哈希表,并用C语言简单实现了。 当然源代码多有参考,此博客旨在交流心得 哈希表原理 结构体说明如下 源代码如下: #include<stdio.h> #include<stdlib.h> #define ...
  • c语言实现哈希表数据结构

    千次阅读 2019-11-08 20:58:27
    "======初始化哈希表=====\n" ) ; init ( & hashTable ) ; printf ( "======插入=====\n" ) ; if ( insert ( & hashTable , 1 ) ) { printf ( "插入成功\n" ) ; } else { printf ( "插入失败\...
  • C语言实现简单哈希表

    千次阅读 2022-01-06 20:17:59
    什么是哈希表 哈希表,也叫散列表,是根据关键码值而直接进行访问的数据结构。通俗点说,就是通过关键值(key)映射到表中的某个位置,以便可以直接访问该节点,以提高查找速度。这个映射函数就是散列函数。 举个例子...
  • C语言实现哈希表 话不多说了,直接上代码 话不多说了,直接上代码 #include #include #define SUCCESS 1 #define UNSUCCESS 0 #define OVERFLOW -1 #define OK 1 3 / 20 #define ERROR -1 typedef int Status;...
  • //初始化哈希表数组 hl - > list = ( List ) malloc ( sizeof ( struct LNode ) * length ) ; for ( int i = 0 ; i < length ; i ++ ) { l - > data = 0 ; l - > Next = NULL ...
  • C语言基于哈希表实现通讯录--附源码
  • 以下是对哈希表实验用C语言实现的代码进行了详细的分析介绍,需要的朋友可以参考下
  • 做项目写业务逻辑的时候经常用到的数据...但是c语言是没有提供这类标准库的,本资源提供的是一个可以在正式项目中使用的纯c语言实现哈希字典。原文链接:https://blog.csdn.net/u013113678/article/details/113765937
  • 哈希表C语言实现)超级简洁版

    千次阅读 2022-03-16 23:06:22
    数据结构设计 //字典类型 #define DICT_TYPE_INT 0 #define DICT_TYPE_STR 1 //键值对 typedef struct dict_entry ... //哈希函数 unsigned int (*hash)(void* key); // table 数组存放 dict_entry 指针
  • 基于C语言实现哈希表(线性探测)

    千次阅读 2018-05-28 17:24:26
    之前在写过的很多的结构...但是如果有一种存储结构,通过某种函数使元素的存储位置与他的关键码之间能够建立一一映射的关系,那么就能够直接地查找到需要地元素,时间复杂度就达到了O(1),那么这种结构就是哈希表。...
  • C语言实现哈希表(key为字符型)

    千次阅读 2016-08-17 10:24:17
    简单实现哈希表的插入和查找功能,简要说明如下: 1、数据结构: struct HashNode {  char* sKey; //键  int nValue; //值  HashNode* pNext; //当Hash值冲突时,指向HASH值相同的下一个...
  • C语言实现哈希表查找算法

    万次阅读 多人点赞 2017-08-18 15:39:34
    哈希表(散列表)是直接通过关键字key得到要查找的记录的内存存储位置。 散列技术是在记录的存储位置和它的关键字之间建立一个确定的对应关系f,使得每个关键字key对应一个存储位置f(key)。 采用散列技术将记录...
  • 哈希表实现---C语言

    2021-07-11 14:45:03
    * 程序名:hash.c,此程序演示哈希表实现,数据元素单链表带头结点。 * 作者:jack 日期:20210711 * 参考作者:C语言技术网(www.freecplus.net), B站UP主:C语言技术网 */ #include <stdio.h> #include ...
  • 使用C语言,初步实现哈希表,使用“链表”的方法,Hash函数是直接“取模”运算
  • 基于C语言实现哈希表(开散列)

    千次阅读 2018-05-29 10:38:21
    上一篇博客写了基于线性探测实现哈希表的一些方法,但若是负载因子较大时,哈希表的查找数据效率还是会很低,下面将使用开散列来实现哈希表的一些操作开散列又称为链地址法(开链法)首先对关键码集合用散列函数计算...
  • 该资源提供一份头文件和实现文件(.h + .c),功能主要包含了哈希表的创建、添加键值、修改键值、统计键值数量、回调自定义、清空哈希表、删除哈希表,基本够用。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,901
精华内容 10,360
关键字:

c语言实现哈希表

友情链接: ROADM.rar