linked hash list test with C

#ifndef _HASH_H_
#define _HASH_H_
#include <stdbool.h>
#include <stdlib.h>
#define SIZE 26

typedef struct node{
    char * word;
    size_t count;
    struct node * next;
}Node, * pnode;

typedef struct words{
    Node * head[SIZE];
}Words;

void init_words(Words * words);

void destroy_words(Words * words);

size_t hash_fun(const char * word);

bool append_word(Words * words, const char * word);

bool delete_word(Words * words, char * word);

void print_words(Words * words);

#endif

#include "hash.h"
#include <string.h>
#include <stdio.h>


static Node * _make_node(const char * word, size_t count, Node * next);

static void _add_node(Node * head, Node * newNode);

static void _delete_next_node(Node * prev);

static Node * _make_node(const char * word, size_t count, Node * next)
{

    char * newStr = (char*)malloc(sizeof(char) * strlen(word));
    memcpy(newStr, word, strlen(word));
    Node * newNode = (Node *)malloc(sizeof(Node));
    newNode->count = count;
    newNode->word = newStr;
    newNode->next = next;
    return newNode;
}

static void _add_node(Node * head, Node * newNode)
{
    newNode->next = head->next;
    head->next = newNode;
}

static void _delete_next_node(Node * prev)
{
    Node * delNode = prev->next;
    prev->next = delNode->next;
    free(delNode->word);
    free(delNode);
}

void init_words(Words * words)
{
    for(int i = 0; i < SIZE; i++)
        words->head[i] = _make_node("",0,NULL);
}

void destroy_words(Words * words)
{
    for(int i = 0; i < SIZE; i++)
    {
        Node * p = words->head[i];
        while(p->next)
            _delete_next_node(p);
        free(p->word);
        free(p);
    }
}

size_t hash_fun(const char * word)
{
    return (word[0] - 'a') % SIZE;    
}

bool append_word(Words * words,const char * word)
{
    size_t index = hash_fun(word);
    Node * current = words->head[index]->next;
    while(current)
    {
        if(!strcmp(current->word, word))
        {
            current->count++;
            return false;
        }
        else current = current->next;
    }
    Node * newNode = _make_node(word,1,NULL);
    _add_node(words->head[index], newNode);
    words->head[index]->count++;
    return true;
}

bool delete_word(Words * words, char * word)
{
    size_t index = hash_fun(word);
    Node * current = words->head[index];
    while(current->next)
    {
        if(!strcmp(current->next->word, word))
        {
            words->head[index]->count--;
            _delete_next_node(current);
            return true;
        }
        current = current->next;
    }
    return false;
}

void print_words(Words * words)
{
    for(int i = 0; i < SIZE; i++)
    {
        if(!words->head[i]->count)
            continue;
        for(Node * p = words->head[i]; p; p=p->next)
            printf("(%s, %zu) ", p->word, p->count);
        printf("
");    
    }
    printf("
");
}

#include <stdio.h>
#include "hash.h"


int main()
{
    char str[][10] = {"good","google","good","been", "between","food","call","been","calloc","destroy","xo","yellow","zero","zoom"};
    int strNum = sizeof(str)/sizeof(str[0]);
    Words w;
    init_words(&w);
    for(int i = 0; i < strNum; i++)
    {
        append_word(&w, str[i]);
    }
    print_words(&w);
    delete_word(&w, "google");
    delete_word(&w, "been");
    delete_word(&w, "zero");
    printf("**************************
");
    print_words(&w);
    destroy_words(&w);
    return 0;
}