Manera rápida de implementar el diccionario en C

Una de las cosas que echo de menos al escribir programas en C es una estructura de datos del diccionario. ¿Cuál es la forma más conveniente de implementar uno en C? No busco rendimiento, sino facilidad para codificarlo desde cero. Tampoco quiero que sea genérico, algo como string-> int servirá. Pero sí quiero que pueda almacenar una cantidad arbitraria de artículos.

Esto se pretende más como un ejercicio. Sé que hay bibliotecas de terceros disponibles que se pueden usar. Pero considere por un momento, que no existen. En tal situación, ¿cuál es la forma más rápida de implementar un diccionario que satisfaga los requisitos anteriores?

La sección 6.6 del lenguaje de programación C presenta una estructura de datos de diccionario simple (tabla hash). No creo que una implementación útil del diccionario pueda ser más simple que esto. Para su comodidad, reproduzco el código aquí.

struct nlist { /* table entry: */
    struct nlist *next; /* next entry in chain */
    char *name; /* defined name */
    char *defn; /* replacement text */
};

#define HASHSIZE 101
static struct nlist *hashtab[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 = hashtab[hash(s)]; np != NULL; np = np->next)
        if (strcmp(s, np->name) == 0)
          return np; /* found */
    return NULL; /* not found */
}

char *strdup(char *);
/* install: put (name, defn) in hashtab */
struct nlist *install(char *name, char *defn)
{
    struct nlist *np;
    unsigned hashval;
    if ((np = lookup(name)) == NULL) { /* not found */
        np = (struct nlist *) malloc(sizeof(*np));
        if (np == NULL || (np->name = strdup(name)) == NULL)
          return NULL;
        hashval = hash(name);
        np->next = hashtab[hashval];
        hashtab[hashval] = np;
    } else /* already there */
        free((void *) np->defn); /*free previous defn */
    if ((np->defn = strdup(defn)) == NULL)
       return NULL;
    return np;
}

char *strdup(char *s) /* make a duplicate of s */
{
    char *p;
    p = (char *) malloc(strlen(s)+1); /* +1 for ’\0’ */
    if (p != NULL)
       strcpy(p, s);
    return p;
}

Tenga en cuenta que si los hashes de dos cadenas chocan, puede provocar un O(n)tiempo de búsqueda. Puede reducir la probabilidad de colisiones aumentando el valor de HASHSIZE. Para una discusión completa de la estructura de datos, consulte el libro.

La forma más rápida sería utilizar una implementación ya existente, como uthash .

Y, si realmente desea codificarlo usted mismo, los algoritmos de uthashpueden ser examinados y reutilizados. Tiene licencia BSD, por lo que, aparte del requisito de transmitir el aviso de derechos de autor, tiene bastante ilimitado en lo que puede hacer con él.

Para facilitar la implementación, es difícil superar la búsqueda ingenua a través de una matriz. Además de alguna comprobación de errores, esta es una implementación completa (no probada).

typedef struct dict_entry_s {
    const char *key;
    int value;
} dict_entry_s;

typedef struct dict_s {
    int len;
    int cap;
    dict_entry_s *entry;
} dict_s, *dict_t;

int dict_find_index(dict_t dict, const char *key) {
    for (int i = 0; i < dict->len; i++) {
        if (!strcmp(dict->entry[i], key)) {
            return i;
        }
    }
    return -1;
}

int dict_find(dict_t dict, const char *key, int def) {
    int idx = dict_find_index(dict, key);
    return idx == -1 ? def : dict->entry[idx].value;
}

void dict_add(dict_t dict, const char *key, int value) {
   int idx = dict_find_index(dict, key);
   if (idx != -1) {
       dict->entry[idx].value = value;
       return;
   }
   if (dict->len == dict->cap) {
       dict->cap *= 2;
       dict->entry = realloc(dict->entry, dict->cap * sizeof(dict_entry_s));
   }
   dict->entry[dict->len].key = strdup(key);
   dict->entry[dict->len].value = value;
   dict->len++;
}

dict_t dict_new(void) {
    dict_s proto = {0, 10, malloc(10 * sizeof(dict_entry_s))};
    dict_t d = malloc(sizeof(dict_s));
    *d = proto;
    return d;
}

void dict_free(dict_t dict) {
    for (int i = 0; i < dict->len; i++) {
        free(dict->entry[i].key);
    }
    free(dict->entry);
    free(dict);
}

Cree una función hash simple y algunas listas de estructuras vinculadas, dependiendo del hash, asigne en qué lista vinculada insertar el valor. Use el hash para recuperarlo también.

Hice una implementación simple hace algún tiempo:

...
#define K 16 // coeficiente de encadenamiento

struct dict
{
    nombre del personaje; / * nombre de la clave * /
    int val; / * valor * /
    struct dict * next; / * campo de enlace * /
};

typedef struct dict dict;
dict * tabla [K];
int inicializado = 0;


nulo putval (char *, int);

void init_dict ()
{   
    inicializado = 1;
    int i;  
    para (i = 0; iname = (char *) malloc (strlen (key_name) +1);
    ptr-> val = sval;
    strcpy (ptr-> nombre, nombre_clave);


    ptr-> next = (struct dict *) tabla [hsh];
    tabla [hsh] = ptr;

}


int getval (char * key_name)
{   
    int hsh = hash (nombre_clave);   
    dict * ptr;
    para (ptr = tabla [hsh]; ptr! = (dict *) 0;
        ptr = (dict *) ptr-> siguiente)
    if (strcmp (ptr-> name, key_name) == 0)
        volver ptr-> val;
    volver -1;
}

GLib y gnulib

Estas son sus mejores apuestas si no tiene requisitos más específicos, ya que están ampliamente disponibles, son portátiles y probablemente eficientes.

• GLib: https://developer.gnome.org/glib/ por el proyecto GNOME. Varios contenedores documentados en: https://developer.gnome.org/glib/stable/glib-data-types.html, incluyendo "Tablas hash" y "Árboles binarios equilibrados". Licencia: LGPL

• gnulib: https://www.gnu.org/software/gnulib/ por el proyecto GNU. Debes copiar, pegar la fuente en tu código. Varios contenedores documentados en: https://www.gnu.org/software/gnulib/MODULES.html#ansic_ext_container, incluidos "rbtree-list", "Linkedhash-list" y "rbtreehash-list". Licencia GPL.

Ver también: ¿Hay alguna biblioteca C de código abierto con estructuras de datos comunes?

Aquí hay un implemento rápido, lo usé para obtener una 'Matriz' (sruct) de una cadena. puede tener una matriz más grande y cambiar sus valores en la ejecución también:

typedef struct  { int** lines; int isDefined; }mat;
mat matA, matB, matC, matD, matE, matF;

/* an auxilary struct to be used in a dictionary */
typedef struct  { char* str; mat *matrix; }stringToMat;

/* creating a 'dictionary' for a mat name to its mat. lower case only! */
stringToMat matCases [] =
{
    { "mat_a", &matA },
    { "mat_b", &matB },
    { "mat_c", &matC },
    { "mat_d", &matD },
    { "mat_e", &matE },
    { "mat_f", &matF },
};

mat* getMat(char * str)
{
    stringToMat* pCase;
    mat * selected = NULL;
    if (str != NULL)
    {
        /* runing on the dictionary to get the mat selected */
        for(pCase = matCases; pCase != matCases + sizeof(matCases) / sizeof(matCases[0]); pCase++ )
        {
            if(!strcmp( pCase->str, str))
                selected = (pCase->matrix);
        }
        if (selected == NULL)
            printf("%s is not a valid matrix name\n", str);
    }
    else
        printf("expected matrix name, got NULL\n");
    return selected;
}

Me sorprende que nadie haya mencionado el conjunto de bibliotecas hsearch / hcreate que, aunque no está disponible en Windows, es un mandato de POSIX y, por lo tanto, está disponible en sistemas Linux / GNU.

El enlace tiene un ejemplo básico simple y completo que explica muy bien su uso.

Incluso tiene una variante segura para hilos, es fácil de usar y muy eficiente.

Una tabla hash es la implementación tradicional de un simple "Diccionario". Si no te importa la velocidad o el tamaño, solo búscalo en google . Hay muchas implementaciones disponibles gratuitamente.

Aquí está el primero que vi : de un vistazo, me parece bien. (es bastante básico. Si realmente desea que contenga una cantidad ilimitada de datos, deberá agregar algo de lógica para "reasignar" la memoria de la tabla a medida que crece).

¡buena suerte!

Hashing es la clave. Creo que use la tabla de búsqueda y la clave hash para esto. Puede encontrar muchas funciones de hashing en línea.

El método más rápido sería usar un árbol binario. Su peor caso también es solo O (logn).