C Sözlüğü Uygulamasının Hızlı Yolu

C'de program yazarken özlediğim şeylerden biri sözlük veri yapısıdır. Birini C'de uygulamanın en uygun yolu nedir? Performans arıyorum değil, sıfırdan kodlama kolaylığı. Ben de genel olmasını istemiyorum - string-> int gibi bir şey yapacak. Ancak, rastgele sayıda öğeyi depolayabilmesini istiyorum.

Bu daha çok bir egzersiz olarak düşünülmüştür. Kullanılabilecek 3. taraf kitaplıkları olduğunu biliyorum. Ama bir an için var olmadıklarını düşünün. Böyle bir durumda, yukarıdaki gereksinimleri karşılayan bir sözlüğü uygulamanın en hızlı yolu budur.

C Programlama Dili Bölüm 6.6, basit bir sözlük (hashtable) veri yapısı sunar. Yararlı bir sözlük uygulamasının bundan daha basit olabileceğini düşünmüyorum. Size kolaylık sağlamak için kodu burada yeniden oluşturuyorum.

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;
}

İki dizenin karmaları çakışırsa, bir O(n)arama süresine yol açabileceğini unutmayın . Değerini artırarak çarpışma olasılığını azaltabilirsiniz HASHSIZE. Veri yapısının eksiksiz bir tartışması için lütfen kitaba bakın.

En hızlı yol, uthash gibi halihazırda var olan bir uygulamayı kullanmaktır .

Ve gerçekten kendiniz kodlamak istiyorsanız, algoritmalar uthashincelenebilir ve yeniden kullanılabilir. BSD lisanslıdır, bu nedenle telif hakkı bildirimini iletme gerekliliği dışında, onunla yapabilecekleriniz konusunda oldukça sınırsızsınız.

Uygulama kolaylığı için, bir dizi içinde safça arama yapmak zor. Bazı hata kontrollerinin yanı sıra, bu tam bir uygulamadır (test edilmemiştir).

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);
}

Basit bir hash fonksiyonu ve hash'e bağlı olarak bazı bağlantılı yapı listeleri oluşturun, değerin ekleneceği bağlı listeyi atayın. Karmayı almak için de kullanın.

Bir süre önce basit bir uygulama yaptım:

...
#define K 16 // zincirleme katsayısı

yapı diktesi
{
    karakter ismi; / * anahtarın adı * /
    int val; / * değer * /
    struct dict * sonraki; / * bağlantı alanı * /
};

typedef struct diktesi;
dikte * tablo [K];
int başlatılmış = 0;


void putval (char *, int);

void init_dict ()
{   
    başlatılmış = 1;
    int i;  
    for (i = 0; iname = (char *) malloc (strlen (key_name) +1);
    ptr-> val = sval;
    strcpy (ptr-> ad, anahtar_adı);


    ptr-> sonraki = (struct dict *) tablo [hsh];
    tablo [hsh] = ptr;

}


int getval (karakter * anahtar_adı)
{   
    int hsh = hash (anahtar_adı);   
    dikte * ptr;
    için (ptr = tablo [hsh]; ptr! = (dict *) 0;
        ptr = (dict *) ptr-> sonraki)
    eğer (strcmp (ptr-> ad, anahtar_adı) == 0)
        dönüş ptr-> val;
    dönüş -1;
}

GLib ve gnulib

Yaygın olarak mevcut, taşınabilir ve muhtemelen verimli olduklarından, daha spesifik gereksinimleriniz yoksa bunlar muhtemelen en iyi bahislerinizdir.

• GLib: GNOME projesi tarafından https://developer.gnome.org/glib/ . Https://developer.gnome.org/glib/stable/glib-data-types.html adresinde belgelenen çeşitli kapsayıcılar, "Karma Tablolar" ve "Dengeli İkili Ağaçlar" dahil. Lisans: LGPL

• gnulib: GNU projesi tarafından https://www.gnu.org/software/gnulib/ . Kaynağı kodunuza kopyalayıp yapıştırmanız gerekmektedir. "Rbtree-list", "linkedhash-list" ve "rbtreehash-list" dahil olmak üzere https://www.gnu.org/software/gnulib/MODULES.html#ansic_ext_container adresinde belgelenen çeşitli kapsayıcılar . GPL lisansı.

Ayrıca bkz: Ortak veri yapılarına sahip herhangi bir açık kaynak C kitaplığı var mı?

işte hızlı bir uygulama, onu bir dizeden bir 'Matrix' (sruct) elde etmek için kullandım. daha büyük bir diziye sahip olabilir ve çalışma sırasında değerlerini de değiştirebilirsiniz:

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;
}

Hiç kimsenin hsearch / hcreate kitaplık setinden bahsetmediğine şaşırdım , ancak bunlar pencerelerde bulunmaz, ancak POSIX tarafından yetkilendirilir ve bu nedenle Linux / GNU sistemlerinde mevcuttur.

Bağlantı, kullanımını çok iyi açıklayan basit ve eksiksiz bir temel örneğe sahiptir.

Hatta iş parçacığı için güvenli bir çeşidi vardır, kullanımı kolaydır ve çok performanslıdır.

Bir hashtable, basit bir "Sözlük" ün geleneksel uygulamasıdır. Hızı veya boyutu önemsemiyorsanız, bunun için google . Ücretsiz olarak kullanılabilen birçok uygulama vardır.

işte ilk gördüğüm şey - bir bakışta bana iyi görünüyor. (Oldukça basit. Eğer gerçekten sınırsız miktarda veri tutmasını istiyorsanız, o zaman tablo belleğini büyüdükçe "yeniden tahsis etmek" için biraz mantık eklemeniz gerekir.)

iyi şanslar!

Hashing anahtardır. Bunun için arama tablosu ve hashing anahtarı kullanmayı düşünüyorum. Birçok hashing işlevini çevrimiçi olarak bulabilirsiniz.

En hızlı yöntem ikili ağaç kullanmaktır. En kötü durumu da sadece O (logn).