数据结构——哈希表使用

        目标：利用哈希表存放若干个单词，用户输入某个单词，查询在哈希表中是否存在该单词

主函数 main.c ↓↓↓↓↓

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "hashtable.h"

int main(void)
{
	struct list_head *parray = NULL;
	int i = 0;
	char str[5][32] = {0};
	char num[32] = {0};
	char cnt[32] = {0};


	for(i = 0; i < 5; i++)
	{
		gets(str[i]);
	}
	
	parray = create_hashtable();
	
	for(i = 0; i < 5; i++)
	{
		insert_hashtable(parray, str[i]);
	}

	show_hashtable(parray);

	printf("请输入要查询的单词:\n");
	gets(num);

#if 1
	if (find_hashtable(parray, num))
	{
		printf("%s 单词存在\n", num);
	}
	else 
	{
		printf("%s 节点不存在\n", num);
	}
#endif

	printf("请输入要删除的单词:\n");
	gets(num);

	delete_hashtable(parray, num);
	printf("已删除 %s 此单词\n", num);

	show_hashtable(parray);

	destroy_hashtable(parray);
	parray = NULL;

	return 0;
}

封装函数 ↓↓↓↓↓

#include "hashtable.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

//创建
struct list_head *create_hashtable(void)
{   
    int i = 0;
    struct list_head *ptmd = NULL;

    ptmd = malloc(MAXNUM * sizeof(struct list_head));
    if(NULL == ptmd)
    {
        return NULL;
    }

    for(i = 0; i < MAXNUM; i++)
    {
        INIT_LIST_HEAD(&ptmd[i]);
    }

    return ptmd;
}

//判断
static int asc_compare(struct list_head *pnew, struct list_head *pnode)
{
    return strcmp((list_entry(pnew, hashnode_t, node)->str), (list_entry(pnode, hashnode_t, node)->str));
}

//插入
int insert_hashtable(struct list_head *pheadlist, char *pstr)
{
    int key = 0;
    hashnode_t *ptmd = NULL;

    ptmd = malloc(sizeof(hashnode_t));
    if(NULL == ptmd)
    {
        return -1;
    }

    strcpy(ptmd->str, pstr);
    if(pstr[1] >= 'A' && pstr[1] <= 'Z')
    {
        key = *pstr - 'A';
    }
    else if(pstr[1] >= 'a' && pstr[1] <= 'z')
    {
        key = *pstr - 'a' + 26;
    }
    list_add_order(&ptmd->node, &pheadlist[key], asc_compare);

    return 0;
}

//打印
int show_hashtable(struct list_head *pheadlist)
{
    int i = 0;
    struct list_head *ptmpnode = NULL;

    for (i = 0; i < MAXNUM; i++)
    {
        if(i >= 0 && i < 26)
        {
            printf("%c: ", (char)i + 'A');//或者+65
        }
        else
        {
            printf("%c: ", (char)i + 'a' - 26);//或者+71
        }
        list_for_each(ptmpnode, &pheadlist[i])
        {
            printf(" %s----", list_entry(ptmpnode, hashnode_t, node)->str);
        }
        printf("\n");
    }

    return 0;
}

//查找
hashnode_t *find_hashtable(struct list_head *pheadlist, char *pstr)
{
    int key = 0;
    struct list_head *ptmpnode = NULL;

    if(pstr[1] >= 'A' && pstr[1] <= 'Z')
    {
        key = *pstr - 'A';
    }
    else if(pstr[1] >= 'a' && pstr[1] <= 'z')
    {
        key = *pstr - 'a' + 26;
    }
    
    list_for_each(ptmpnode, &pheadlist[key])
    {
        if (strcmp(list_entry(ptmpnode, hashnode_t, node)->str, pstr) == 0)
        {
            return list_entry(ptmpnode, hashnode_t, node);
        }
        else if (list_entry(ptmpnode, hashnode_t, node)->str > pstr)
        {
            break;
        }
    }
    
    return NULL;
}

//删除
int delete_hashtable(struct list_head *parray, char *pstr)
{
    hashnode_t *ptmpnode = NULL;
    int cnt = 0;

    while (1)
    {
        ptmpnode = find_hashtable(parray, pstr);
        if (NULL == ptmpnode)
        {
            break;
        }

        list_del(&ptmpnode->node);
        free(ptmpnode);
        cnt++;
    }
    
    return cnt;
}

//销毁
int destroy_hashtable(struct list_head *parray)
{
    int i = 0;
    hashnode_t *ptmpnode = NULL;
    hashnode_t *pnextnode = NULL;

    for (i = 0; i < MAXNUM; i++)
    {
        list_for_each_entry_safe(ptmpnode, pnextnode, &parray[i], node)
        {
            free(ptmpnode);
        }
    }

    free(parray);

    return 0;
}

结构体函数↓↓↓↓↓

#ifndef __HASHTABLE_H__
#define __HASHTABLE_H__

#include "list.h"

typedef struct hashnode
{
    struct list_head node;
    char str[32];
}hashnode_t;

#define MAXNUM      52

extern struct list_head *create_hashtable(void);
extern int insert_hashtable(struct list_head *pheadlist, char *pstr);
extern int show_hashtable(struct list_head *pheadlist);
extern hashnode_t *find_hashtable(struct list_head *pheadlist, char *pstr);
extern int delete_hashtable(struct list_head *parray, char *pstr);
extern int destroy_hashtable(struct list_head *parray);

#endif