Check for a word in a dictionary in C - c

Question

I have a project in which I have a file (.dic) with many words with different sizes. And another file (.pal) with some words. For each word of the .pal file, I have to find its position in a list of words with the same number of words, ordered alphabetically from the .dic file.
For example,
in the .dic file:
car
banana
dog
flower
tar
So the dictionary would be something like:
3 letters: [car->dab->dog->tar]
6 letters: [banana->flower]
in the .pal file:
dog
flower
So the output would be:
dog in position 3
flower in position 2
My question is: What is the best data structure to implement this in C, so that it takes the least memory and time?
I was thinking of having a matrix in which each the first index (index1) corresponds to the number of letters in the word, and the second index (index2) corresponds to the first letter of the word I'm looking for. Each element of that matrix is a list of words with index1 letters and starting in letter index2.
Example:
| A | B | C | .....
_______________
1|list|list|list|
2|list|....|....|
3|...
.
.
So "dog" would be in a list inside matrix[3][D].
Problem 1: the matrix will have hole if there aren't words with all different number of letters or different first letters -> too much memory wasted?
Problem 2: to know the position I asked before I would have to sum up the number of elements of each list before the one I'm using.
Example: "dog" position would be
number of element in list [3][A]+number of element in list [3][B]+number of element in list [3][C]+"dog" position in the list
So when I inserted a word in a list, I would have to update the numbers of elements of the lists in the next matrix elements. -> time consuming?
So what do you think of this method? Do you have better ideas?

Answer 1

What is the best data structure to implement this in C, so that it takes the least memory and time?
It's difficult to get both least memory and least time. If you want to keep memory usages as low as possible, you'll need dynamic memory allocation which is expensive when considering time.
To get low memory usage, you could go for the following data structure:
#define MAX_WORD_LEN 50
char** dic[MAX_WORD_LEN];
You use it like this:
index 0: -----> char*, char*, char*, ... // Words with length 1
| | |
| | ------> string (i.e. char, '\0')
| |
| ------> string (i.e. char, '\0')
|
------> string (i.e. char, '\0')
index 1: -----> char*, char*, ... // Words with length 2
| |
| ------> string (i.e. char, char, '\0')
|
------> string (i.e. char, char, '\0')
This allows you to store a variable number of words for each length and you don't allocate more memory than needed for each string. It is like a matrix but the benefit is that each row can have different number of columns.
You will however need quite some dynamic memory handling, i.e. malloc, realloc and strdup.
To save some execution time you should grow the "char*, char*, char*, ..." array by some N larger than 1 and set the unused entries to NULL. That will save a lot of realloc but you'll need to keep track on the number of allocated elements in each row. That could call for something like:
struct x
{
char** data;
int number_allocated;
}
#define MAX_WORD_LEN 50
struct x dic[MAX_WORD_LEN];
If memory usage is real hot, you can avoid the "char*, char* ..." array and just use one big char array for each word length. Like:
index 0: -----> 'a', '\0', 'I', '\0', ...
index 1: -----> 'b', 'e', '\0', 't', 'o', '\0', ....
You can do this because all words in a char-array has the same length.
In this case you would have something like:
struct x
{
char* data;
int bytes_allocated;
int number_of_words;
}
#define MAX_WORD_LEN 50
struct x dic[MAX_WORD_LEN];