impossible de remplir completement une table de hachage à partir d'un tableau

**étoile de mer** · 24/12/2009, 09h18

Bonjour à tous,
Ça fait deux jours que je suis bloquée : J'ai une fonction qui lit le contenu d'un tableau rempli de structure de MotCompact(structure de donnée) et de les mettre dans une table de hachage de structure. En fait après remplissage de la table j'étais surprise qu'il manque deux éléments qui n'ont pas été dans la table de hachage. Je vois pas pourquoi franchement.c'est pour ça je m'adresse et à vos compétences .Merci d'avoir pri la peine de m'aider

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void RemplirTableHachageMots(MotCompact const pcMots[], struct  TableHachage_BiSequence * THash,size_t nbMot)
{
 
    size_t iMot;
    size_t jMot;
    FILE *pfOut;
    pfOut = fopen("mot.txt", "w");
    if (pfOut!=NULL)
    {
        // parcourir le tableau MotCompact pour faire toute les association possible
        // Parcours quadratique
        for (iMot=0 ; iMot < nbMot ; iMot++)
        {
            for ( jMot = 0 ; jMot < nbMot ; jMot++ )
            {
                fprintf(pfOut,"%s\n",GetMotCompact(pcMots+iMot));
                TableHachage_BiSequence_ajouter_mots(THash, pcMots+iMot, pcMots+jMot);
            }
        }
    }
    fclose(pfOut);
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
int TableHachage_BiSequence_ajouter_mots(struct TableHachage_BiSequence *pThis, const MotCompact* pNouveauMotG, const MotCompact* pNouveauMotD)
{
    const char* motG = GetMotCompact(pNouveauMotG);
    const char* motD = GetMotCompact(pNouveauMotD);
    char* seqSim = NULL;
    size_t nbLettersEnsemble = strlen(motG) + strlen(motD) + 2;	// + 2 car il nous faut un espace et un '\0'
    unsigned int cle = 0;
 
    seqSim = malloc(nbLettersEnsemble * sizeof(char));
    if ( seqSim == NULL )
    {
        printf("Problème allocation mémoire dans TableHachage_BiSequence_ajouter_mots\n");
        return -1;
    }
 
    // Reconstruction de la séquence à partir de deux mots
    strcpy(seqSim, motG);
    strcat(seqSim, " ");
    strcat(seqSim, motD);
    cle = hash_chaine(seqSim);
 
    // Grace à la clé nous avons la BiSequence correspondante, donc nous remplissons la structure avec les mots
    // Comme nous avons une tablea de hachage qui contient des tableaux dynamique, le premier élément n'est peut être pas le bon
    // Nous parcourons le tableau pour savoir
 
    struct BiSequence * pSeq = RechercherMot(pThis->seaux[cle].tab, pThis->seaux[cle].taille, seqSim);
 
    if (pSeq!=NULL)
    {
 
        pSeq->MotGauche = pNouveauMotG;
        pSeq->MotDroit = pNouveauMotD;
        //  printf("La sequence n'a pas ete trouve\n");
 
    }
 
    free (seqSim);
 
    return 0;
}

**Médinoc** · 27/12/2009, 18h55

Peux-tu afficher le contenu de chaque tableau de la table?
Un truc du genre:

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
size_t iHash, iSeq;
for(iHash=0 ; iHash<TAILLEHASH, iHash++)
{
	if(THash->seaux[iHash].taille != 0)
	{
		printf("%lu :\n", (unsigned long)iHash);
		for(iSeq=0 ; iSeq<THash->seaux[iHash].taille ; iSeq++)
		{
			struct BiSequence const *pBs = &(THash->seaux[iHash].tab[iSeq]);
			char const *mot = GetMotCompact(pBs->mot);
			printf("\t%s (longueur %lu)\n", mot, (unsigned long)strlen(mot));
		}
	}
}

Et poste le résultat, qu'on voie s'il y a un truc bizarre.

**étoile de mer** · 27/12/2009, 20h19

Re,
voilà le resultat

0 :
ne bougez (longueur 9)
3 :
marqué dans (longueur 12)
10 :
ras le (longueur 6)
11 :
la nounou (longueur 9)
13 :
vous navez (longueur 10)
14 :
ne risquait (longueur 11)
16 :
aime il (longueur 7)
27 :
je prends (longueur 9)
39 :
aime vous (longueur 9)
40 :
aime je (longueur 7)
55 :
risquait rien (longueur 13)
60 :
rien Ça (longueur 8)
66 :
les fantômes (longueur 13)
69 :
gardez la (longueur 9)
70 :
pas question (longueur 12)
74 :
bougez pas (longueur 10)
78 :
cétait pas (longueur 11)
79 :
pas marqué (longueur 11)
83 :
aime tant (longueur 9)
90 :
bol de (longueur 6)
91 :
quon ne (longueur 7)
104 :
aime navrée (longueur 12)
108 :
avion pour (longueur 10)
120 :
le bol (longueur 6)
130 :
comment savais (longueur 14)
138 :
savais tu (longueur 9)
lannonce je (longueur 11)
140 :
kathy bobby (longueur 11)
145 :
que je (longueur 6)
153 :
je ne (longueur 5)
159 :
la tête (longueur 8)
164 :
aime ne (longueur 7)
167 :
question que (longueur 12)
169 :
navez rien (longueur 10)
191 :
tête baissée (longueur 14)
223 :
le savais (longueur 9)
226 :
va toi (longueur 6)
245 :
aime ras (longueur 8)
265 :
dans lannonce (longueur 13)
272 :
rien accrochez (longueur 14)
276 :
de jouer (longueur 8)
277 :
le er (longueur 5)
279 :
tu quon (longueur 7)
280 :
accrochez vous (longueur 14)
302 :
nétait pas (longueur 11)
305 :
bobby loncle (longueur 12)
310 :
aime cétait (longueur 12)
322 :
je démissionne (longueur 15)
324 :
er avion (longueur 8)
327 :
aime gardez (longueur 11)
362 :
ne le (longueur 5)
367 :
prends le (longueur 9)
382 :
navrée kathy (longueur 13)
426 :
il nétait (longueur 10)
428 :
loncle les (longueur 10)
438 :
savais pas (longueur 10)
442 :
aime comment (longueur 12)
460 :
vous aime (longueur 9)
465 :
pour newark (longueur 11)
483 :
Ça va (longueur 6)
493 :
jouer la (longueur 8)
500 :
vous abandonne (longueur 14)
je vous (longueur 7)

**étoile de mer** · 27/12/2009, 20h22

Voilà la fonction de tri :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
void TrieTable( struct  TableHachage_BiSequence * TH)
{
    size_t  i;
    for (i=0;i<TAILLEHASH;i++)
    {
        qsort ( TH->seaux[i].tab, TH->seaux[i].taille, sizeof(struct BiSequence), cmpTableauDynamique_struct);
    }
}

**étoile de mer** · 27/12/2009, 21h20

Apres l'appel de la fonction de tri des tableau la fonction de tri appelée 2 fois):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
int main(int argc, char *argv[])
{
    TraiterFichBinaire();
    return   0;
}
void TraiterFichBinaire ()
{
 
    const   char*   MotFR="table1MotFR.bin";
    const   char*   MotEN="table1MotEn.bin";
    const   char*   SeqFR="table2MotFR.bin";
    const   char*   SeqEN="table2MotEn.bin";
    struct TableHachage_BiSequence*  TH_FR;
    struct TableHachage_BiSequence*  TH_EN;
 
    // Ces variables sont pour les sequences
    struct char_fbtAllocator  *pAllocCaracsFR_seq=NULL, *pAllocCaracsEN_seq=NULL;
    struct int_fbtAllocator *pAllocLignesFR_seq=NULL,  *pAllocLignesEN_seq=NULL;
    size_t *pTaillesTableFR_seq=NULL,*pTaillesTableEN_seq=NULL;
    size_t nbCaracsFR_seq=0, nbCaracsEN_seq=0, nbSeqFR=0,nbSeqEN=0;
    unsigned int  nbLignesFR_seq=0,nbLignesEN_seq=0;
    MotCompact * pSeqFR = NULL;
    MotCompact * pSeqEN = NULL;
 
    // Ces variables sont pour les mots (gauches et droits)
    struct char_fbtAllocator  *pAllocCaracsFR_mots=NULL, *pAllocCaracsEN_mots=NULL;
    struct int_fbtAllocator *pAllocLignesFR_mots=NULL,  *pAllocLignesEN_mots=NULL;
    size_t *pTaillesTableFR_mots=NULL,*pTaillesTableEN_mots=NULL;
    size_t nbCaracsFR_mots=0, nbCaracsEN_mots=0, nbMotsFR=0,nbMotsEN=0;
    unsigned int  nbLignesFR_mots=0,nbLignesEN_mots=0;
    MotCompact * pMotsFR = NULL;
    MotCompact * pMotsEN = NULL;
 
    // Chargement des sequences (FR et EN)
 
    if (CompterToutesTablesFichBinaire2(SeqFR,&nbSeqFR, &nbCaracsFR_seq, &nbLignesFR_seq)<0)
    {
        goto LNettoyage;
    }
 
    if (CompterToutesTablesFichBinaire2(SeqEN,&nbSeqEN, &nbCaracsEN_seq, &nbLignesEN_seq)<0)
    {
        goto LNettoyage;
    }
 
 
    pAllocCaracsFR_seq = char_CreateFbtAllocator(nbCaracsFR_seq);
    pAllocCaracsEN_seq= char_CreateFbtAllocator(nbCaracsEN_seq);
 
    if (pAllocCaracsFR_seq==NULL ||  pAllocCaracsEN_seq==NULL)
    {
 
        goto LNettoyage;
    }
 
    pAllocLignesFR_seq = int_CreateFbtAllocator(nbLignesFR_seq);
    pAllocLignesEN_seq = int_CreateFbtAllocator(nbLignesEN_seq);
 
    if ( pAllocLignesFR_seq==NULL|| pAllocLignesEN_seq==NULL)
    {
        goto LNettoyage;
    }
    printf("%d",nbSeqFR);
 
    pSeqFR = LireToutesTablesFichBinaire(SeqFR,nbSeqFR, pAllocCaracsFR_seq, pAllocLignesFR_seq);
 
    pSeqEN = LireToutesTablesFichBinaire(SeqEN,nbSeqEN, pAllocCaracsEN_seq, pAllocLignesEN_seq);
 
    if (pSeqFR==NULL|| pSeqEN==NULL)
    {
 
        DetruireTableauMotsCompacts(pSeqFR), pSeqFR=NULL;
        DetruireTableauMotsCompacts(pSeqEN), pSeqEN=NULL;
        goto LNettoyage;
 
    }
    // Chargement des mots (gauches et droites) (FR et EN)
 
 
    if (CompterToutesTablesFichBinaire2(MotFR,&nbMotsFR, &nbCaracsFR_mots, &nbLignesFR_mots)<0)
    {
        goto LNettoyage;
    }
 
    if (CompterToutesTablesFichBinaire2(MotEN,&nbMotsEN, &nbCaracsEN_mots, &nbLignesEN_mots)<0)
    {
        goto LNettoyage;
    }
 
    pAllocCaracsFR_mots = char_CreateFbtAllocator(nbCaracsFR_mots);
    pAllocCaracsEN_mots = char_CreateFbtAllocator(nbCaracsEN_mots);
 
    if (pAllocCaracsFR_mots == NULL ||  pAllocCaracsEN_mots == NULL)
    {
        goto LNettoyage;
    }
 
    pAllocLignesFR_mots = int_CreateFbtAllocator(nbLignesFR_mots);
    pAllocLignesEN_mots = int_CreateFbtAllocator(nbLignesEN_mots);
 
    if ( pAllocLignesFR_mots == NULL || pAllocLignesEN_mots == NULL)
    {
        goto LNettoyage;
    }
 
    pMotsFR = LireToutesTablesFichBinaire(MotFR,nbMotsFR, pAllocCaracsFR_mots, pAllocLignesFR_mots);
    pMotsEN = LireToutesTablesFichBinaire(MotEN,nbMotsEN, pAllocCaracsEN_mots, pAllocLignesEN_mots);
    if (pMotsFR==NULL|| pMotsEN==NULL)
    {
        DetruireTableauMotsCompacts(pMotsFR), pMotsFR=NULL;
        DetruireTableauMotsCompacts(pMotsEN), pMotsEN=NULL;
        goto LNettoyage;
    }
 
 
    TH_FR=CreerSimpleTableHachage();
    TH_EN=CreerSimpleTableHachage();
    printf("Remplissage de  la  table   de  hachage\n");
    RemplirTableHachageSeq(pSeqFR, TH_FR,nbSeqEN);
    TrieTable(TH_FR);
     DumpTable(TH_FR);
 
    RemplirTableHachageMots(pMotsFR, TH_FR,nbMotsFR);
 
    RemplirTableHachageSeq(pSeqEN, TH_EN,nbSeqEN);
    TrieTable(TH_EN);
 
    RemplirTableHachageMots(pMotsEN, TH_EN,nbMotsEN);
 
    printf("calcul  des regles");
    GenererRegle2FR1EN(TH_FR,pMotsEN,nbMotsEN);
    DetruireTableauMotsCompacts(pSeqFR), pSeqFR=NULL;
    DetruireTableauMotsCompacts(pSeqEN), pSeqEN=NULL;
 
    DetruireTableauMotsCompacts(pMotsFR), pMotsFR=NULL;
    DetruireTableauMotsCompacts(pMotsEN), pMotsEN=NULL;
 
 
LNettoyage:
    free(pTaillesTableFR_seq), pTaillesTableFR_seq=NULL;
    free(pTaillesTableEN_seq), pTaillesTableEN_seq=NULL;
 
    free(pTaillesTableFR_mots), pTaillesTableFR_mots=NULL;
    free(pTaillesTableEN_mots), pTaillesTableEN_mots=NULL;
}

**étoile de mer** · 27/12/2009, 23h58

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void  DumpTable(struct TableHachage_BiSequence const *THash)
{
    FILE*   pfOut;
 
 size_t iHash, iSeq;
  pfOut = fopen("table de  hash.txt", "w");
    if (pfOut!=NULL)
    {
for(iHash=0 ; iHash<TAILLEHASH; iHash++)
{
	if(THash->seaux[iHash].taille != 0)
	{
		fprintf(pfOut,"%lu :\n", (unsigned long)iHash);
		for(iSeq=0 ; iSeq<THash->seaux[iHash].taille ; iSeq++)
		{
			struct BiSequence const *pBs = &(THash->seaux[iHash].tab[iSeq]);
			char const *mot = GetMotCompact(pBs->seq);
			  fprintf(pfOut,"\t%s (longueur %lu, %s)\n", mot, (unsigned long)strlen(mot), ( pBs->MotGauche!=NULL ? "OK" : "Manque" ));
		}
	}
}
}
fclose(pfOut);
}

impossible de remplir completement une table de hachage à partir d'un tableau

C

Vue hybride

Discussions similaires

Partager

Partager