Question

I’m trying to create a trie structure which can be inserted words, but the struct has to be exactly like this:

typedef struct tNode_t {
    struct tNode_t **l;
    char *w;
  } tNode;

**l is a pointer to an array of 27 pointers to tNodes, thats the part I don’t understand.

If the array is of pointers to tNodes, how do I insert words into it? And since the size of the array is 27 (26 lower case letters a-z and the terminating character) how do you know where to input the word depending on what the beginning letter is?

Answer 1

Let’s suppose the word is ‘cab’.

Roughly speaking, the member w points to a character. 26 of the nodes in the list l are for letters ‘a’ through ‘z’.

Given the word ‘cab’, the first letter is ‘c’, so you’ll look in the root node pointer for root->l[3], which contains pointers to all the words starting with ‘c’; call it tNode *letter = root->l[3];. Then you’ll look for letter->l[1] for the words starting with ‘ca’; letter = letter->l[1];. Then you’ll look for letter->l[2] for the words starting with ‘cab’. At this point, you know that you’ve reached the end of the word your searching for, and letter->w != 0 tells you that the word is valid and gives you the text of the word. There may also be other words further down the tree (for ‘cabs’, ‘cable’, ‘cabal’, etc).

You will have been taught something about this, or given some specification. There are probably other ways to fill in the details.

I’m not clear that using a dynamically allocated array is better than using tNode *l[27]; in the structure (with appropriate adjustments to the declaration), but that’s a separate discussion. I’ve blithely assumed the 27th node in the list has no deeper significance. You could look up such things on the web, of course: Wikipedia tends to be a reasonable source for non-contentious issues related to computer science, but I’ve not studied the linked page yet.

---

l isn’t an array; it’s a pointer to an array of pointers, which is confusing to me.

Pointer variables live a dual life — Dr Jekyll and Mr Hyde — and can be regarded as pointers or (casually) arrays.

If you write char *str, str isn’t an array of characters; it is a pointer to (the first character of) an array of characters. You can use str[i] to access the i^th character in the string. In the same way, char **argv isn’t an array of strings; it is a pointer to (the first string of) an array of character strings. You can use argv[i] to access the i^th argument to a main program.

And in this trie structure, l isn’t an array of tNode *; it is a pointer to (the first element of) an array of trie structures. But you can use trie->l[i] to access the i^th trie structure in the list pointed to by trie->l.

---

Working code

I hadn’t played with tries before, so I put together the code below based on your data structure. Whether it’s formally correct or not is something you’ll need to investigate; the code below works for me for the given test cases, and valgrind gives the code a clean bill of health (no leaked memory, no memory abuse).

The code forcibly includes what would normally be in a header file. As far as the outside world is concerned, the trie type (tNode) is opaque.

#ifndef TRIE_H_INCLUDED
#define TRIE_H_INCLUDED

typedef struct tNode_t tNode;
extern void trie_add_word(tNode *trie, char const *word);
extern char const *trie_find_word(tNode *trie, char const *word);
extern void trie_print(tNode *trie);
extern tNode *trie_new(void);
extern void trie_free(tNode *trie);

#endif /* TRIE_H_INCLUDED */

/*#include "trie.h"*/
#include <assert.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>

struct tNode_t
{
    struct tNode_t **l;
    char            *w;
};

static void db_print(char const *fmt, ...);

tNode *trie_new(void)
{
    tNode *trie = malloc(sizeof(tNode));
    assert(trie != 0);      // Abysmal way to validate memory allocation
    trie->w = 0;
    trie->l = (tNode **)calloc(27, sizeof(tNode *));
    assert(trie->l != 0);   // Abysmal way to validate memory allocation
    return(trie);
}

void trie_free(tNode *trie)
{
    assert(trie != 0);
    assert(trie->l != 0);
    for (size_t i = 0; i < 27; i++)
    {
        if (trie->l[i] != 0)
            trie_free(trie->l[i]);
    }
    free(trie->l);
    free(trie->w);
    free(trie);
}

static void add_word_suffix(tNode *trie, char const *word, char const *suffix)
{
    int c;
    assert(trie != 0);
    assert(trie->l != 0);
    db_print("-->> %s: word [%s], suffix [%s]\n", __func__, word, suffix);
    while ((c = *suffix++) != '\0')
    {
        if (isalpha(c))
        {
            db_print("---- %s: letter %c (index %d)\n", __func__, c, c - 'a' + 1);
            c = tolower(c) - 'a' + 1;
            assert(trie->l != 0);
            if (trie->l[c] == 0)
                trie->l[c] = trie_new();
            db_print("---- %s: recurse: [%s]/[%s]\n", __func__, word, suffix);
            add_word_suffix(trie->l[c], word, suffix);
            db_print("<<-- %s\n", __func__);
            return;
        }
    }
    if (trie->w != 0)
    {
        db_print("---- %s: trie already contains word [%s] at [%s]\n", __func__, word, trie->w);
        return;
    }
    trie->w = strdup(word);
    db_print("<<-- %s: inserted word [%s]\n", __func__, trie->w);
}

void trie_add_word(tNode *trie, char const *word)
{
    add_word_suffix(trie, word, word);
}

static char const *find_word_suffix(tNode *trie, char const *word, char const *suffix)
{
    int c;
    db_print("-->> %s: word [%s] suffix[%s]\n", __func__, word, suffix);
    for ( ; (c = *suffix) != '\0'; suffix++)
    {
        if (isalpha(c))
        {
            db_print("---- %s: letter %c\n", __func__, c);
            c = tolower(c) - 'a' + 1;
            if (trie->l[c] == 0)
                return(0);
            char const *rv = find_word_suffix(trie->l[c], word, suffix+1);
            if (rv == 0)
            {
                db_print("<<-- %s: missing [%s]/[%s]\n", __func__, word, suffix);
                return 0;
            }
            db_print("<<-- %s: found [%s] for [%s]/[%s]\n", __func__, rv, word, suffix);
            return rv;
        }
    }
    if (trie->w == 0)
    {
        db_print("<<-- %s: missing [%s]/[%s]\n", __func__, word, suffix);
        return 0;
    }
    db_print("<<-- %s: found [%s] for [%s]/[%s]\n", __func__, trie->w, word, suffix);
    return(trie->w);
}

char const *trie_find_word(tNode *trie, char const *word)
{
    return find_word_suffix(trie, word, word);
}

void trie_print(tNode *trie)
{
    assert(trie != 0);
    assert(trie->l != 0);
    if (trie->w != 0)
        printf("%s\n", trie->w);
    for (size_t i = 0; i < 27; i++)
    {
        if (trie->l[i] != 0)
            trie_print(trie->l[i]);
    }
}

static int debug = 0;

static void db_print(char const *fmt, ...)
{
    if (debug > 0)
    {
        va_list args;
        va_start(args, fmt);
        vprintf(fmt, args);
        va_end(args);
    }
}

int main(int argc, char **argv)
{
    tNode *trie = trie_new();

    /* Set debugging - and use argv */
    if (argc > 1 && argv[argc] == 0)
        debug = 1;

    /* First test */
    char const *word = "cab";
    trie_add_word(trie, word);
    char const *leaf = trie_find_word(trie, word);
    printf("Leaf word = %s\n", leaf);
    trie_free(trie);

    /* Second, more comprehensive test */
    static char const *words[] =
    {
        "cabal",         "cabbie",
        "cab",           "centre",
        "cinema",        "cold",
        "culminate",     "culmination",
        "duck",          "cabs",
        "amniocentesis", "amniocentesis",
        "amniocentesis", "cam",
        "cab",           "cab",
        "zulu",          "alpha",
        "bravo",         "Charlie",
        "delta",         "echo",
        "foxtrot",       "golf",
        "hotel",         "India",
        "Juliet",        "kilo",
        "Lima",          "Mike",
        "November",      "Oscar",
        "Papa",          "Quebec",
        "Romeo",         "Sierra",
        "Tango",         "uMBRelLA",
        "Victor",        "Whisky",
        "X-ray",         "Yankee",
        "Zulu",          "Aquarius",
    };
    size_t num_words = sizeof(words) / sizeof(words[0]);
    size_t counter = 0;

    /* First time, add every other word; second time, every word */
    for (size_t mod = 2; mod > 0; mod--)
    {
        trie = trie_new();
        printf("\nTest %zu\n", ++counter);
        for (size_t i = 0; i < num_words; i++)
        {
            if (i % mod == 0)
                trie_add_word(trie, words[i]);
            char const *leaf = trie_find_word(trie, words[i]);
            if (leaf == 0)
                printf("Word [%s] is missing\n", words[i]);
            else
                printf("Word [%s] for [%s]\n", leaf, words[i]);
        }
        printf("\nTrie:\n");
        trie_print(trie);
        trie_free(trie);
    }

    return(0);
}

The code uses assert() for memory allocation checking. It is convenient but abysmal style. Do not mimic that. You could decide to combine the trie_find_word() and trie_add_word() functionality into a single function if you wished. You can see fairly detailed diagnostics by passing an argument (any argument) to the test program.

The code uses 27 (not in a macro or enum), but it would work fine with just 26 elements in the array if you remove the + 1 that appears in a couple of places to convert 'a' to 1 (it would convert it to 0 instead).