Discussion :

[jerofr]

Salut à tous,

Je suis en train de créer une classe qui permet de construire un arbre à lettres.
L’idée est de regrouper tous les mots en un arbre dont chaque arc représente une lettre. Donc un mot sera représenté par un chemin de la racine à un nœud contenant la valeur “fin de mot”.
En fait, il s'agit d'une manière compacte de représenter un ensemble de mot, comme par exemple un dictionnaire. Je veux ajouter deux méthodes, l'une pour tester si un mot introduit par l'utilisateur appartient déjà à l'arbre et une autre méthode pour permettre d'y ajouter un mot. J'utilise pas la JTree, tout est fait avec l'array.
Je vous envoie ci-dessous mon code avec quelques commentaires.

Quelqu'un pourrait m'aider?

Merci.

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
 
import java.io.*; 
import java.util.*; 
public class ArbreLettre
{ 
    char lettre; 
    boolean finDeMot; 
    ArrayList lettresSuivantes; 
 
 
    /* constructeur */ 
    ArbreLettre(char c)
    { 
        lettre = c; 
        finDeMot = false; 
        lettresSuivantes = new ArrayList(); 
    } 
 
 
    /* permet de modifier la variable finDeMot 
       pour indiquer si un sous-arbre correspond ou non à la fin d'un mot */ 
    void setFinDeMot(boolean b)
    { 
        finDeMot = b; 
    } 
 
 
    /* teste si l'arbre correspond à la fin d'un mot (dernière lettre) */ 
    boolean isFinDeMot()
    { 
        return finDeMot; 
    } 
 
 
    /* teste si le caractère c est l'une des lettres suivant la lettre courante */ 
    boolean contientLettre(char c)
    { 
        for (int i=0; i<lettresSuivantes.size();i++)
	{ 
            ALettre a = (ALettre)lettresSuivantes.get(i); 
            if (a.lettre == c) return true; 
        } 
        return false; 
    } 
 
 
    /* retourne le sous-arbre (lettre suivante) correspondant au caractère c */ 
    ALettre getSousArbre(char c)
    { 
        for (int i=0; i<lettresSuivantes.size();i++)
	{ 
            ALettre a = (ALettre)lettresSuivantes.get(i); 
            if (a.lettre == c) return a; 
        } 
        return null; 
    } 
 
 
    /* ajoute mot dans l'arbre à lettres */ 
    void ajouterMot(String mot){ 
 
    } 
    /* teste si mot existe dans l'arbre à lettre */ 
    boolean contientMot(String mot){ 
 
    }
 
}

[bigbear19]

Salut,

Juste pour avoir quelques précisions sur ta structure:
- peux-tu détailler un peu plus l'objet ALettre.
- comment remplis-tu l'ArrayList lettreSuivantes ?

[jerofr]

Salut,
Merci pour la réponse.
En fait ce que je veux faire c'est:
Créer les méthodes contientMot et ajouterMot.
Ensuite d'utiliser cette classe pour construire un arbre à lettre à partir d'un fichier texte. Finalement lire le fichier et afficher tous les mots qui ne se trouvent pas dans l'arbre à lettres construit à partir du premier fichier.

C'est la création de ces 2 méthodes qui me posent problème. Pour le reste c'est bon.

Je pense que la solution la plus facile est de faire avec récursivité,il faudrait utiliser les deux methodes contientlettres et getsousarbre
dans un appel récursif pour les deux methodes contientMot et ajouterMot.

Le principe est le même, donc si je peux trouver l'algorithme correct pour la méthode ajouterMot alors c'est exactement
le même principe pour l'autre méthode c'est juste au lieu d'ajouter il faut renvoyer un booléen.

Voilà...mais pour l'instant je n'ai pas réussi.

Quelqu'un pourrait-m'aider?

Voici une version plus récente de mon code:

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
 
import java.io.*; 
import java.util.*; 
 
public class ALettre
{ 
	char lettre; 
	boolean finDeMot; 
	ArrayList lettresSuivantes; 
 
	/* constructeur */ 
	ALettre(char c)
	{ 
		lettre = c; 
		finDeMot = false; 
		lettresSuivantes = new ArrayList(); 
	}
 
	/* permet de modifier la variable finDeMot 
	pour indiquer si un sous-arbre correspond ou non à la fin d'un mot */ 
	void setFinDeMot(boolean b)
	{ 
		finDeMot = b; 
	}
 
	/* teste si l'arbre correspond à la fin d'un mot (dernière lettre) */ 
	boolean isFinDeMot()
	{ 
		return finDeMot; 
	}
 
	/* teste si le caractère c est l'une des lettres suivant la lettre courante */ 
	boolean contientLettre(char c)
	{ 
		for (int i=0; i<lettresSuivantes.size();i++)
		{ 
			ALettre a = (ALettre)lettresSuivantes.get(i); 
			if (a.lettre == c) 
				return true; 
		} 
		return false; 
	}
 
	/* retourne le sous-arbre (lettre suivante) correspondant au caractère c */ 
	ALettre getSousArbre(char c)
	{ 
		for (int i=0; i<lettresSuivantes.size();i++)
		{ 
			ALettre a = (ALettre)lettresSuivantes.get(i); 
			if (a.lettre == c) 
				return a; 
		} 
		return null; 
	}
 
 
	/* ajoute mot dans l'arbre à lettres */ 
	void ajouterMot(String mot)
	{ 
 
	}
 
	/* teste si mot existe dans l'arbre à lettre */ 
	boolean contientMot(String mot)
	{ 
 
        }
 
 
	/* lecture du fichier dico, construction de l'arbre et vérification */ 
	public static void main(String[] args)
	{
		String fichier ="test.txt";
		String fichier1 = "test1.txt";
		String mot, lin;
		StringTokenizer ligneToken;
 
		ALettre p;
		p = new ALettre('A');
		System.out.println("ça marche!!");
 
		//lecture du fichier texte          
		try
		{
			InputStream input = new FileInputStream(fichier);
			InputStreamReader streamReader = new InputStreamReader(input);
			BufferedReader br = new BufferedReader(streamReader);
 
			while ((lin = br.readLine())!=null)
			{
				System.out.println("ça marche!!");
				ligneToken = new StringTokenizer(lin);
 
				while (ligneToken.hasMoreTokens()) 
				{
					System.out.println("ça marche!!");
					mot = (ligneToken.nextToken());
 
					System.out.println(mot);
					p.ajouterMot(mot.toLowerCase());           
				}           
			}
		br.close();
		}
		catch (Exception e)
		{
		}
 
		//recherche du fichier texte          
		try
		{
			InputStream input = new FileInputStream(fichier1);
			InputStreamReader streamReader = new InputStreamReader(input);
			BufferedReader br = new BufferedReader(streamReader);
 
			while ((lin = br.readLine())!=null)
			{
				System.out.println("ça marche!!");
				ligneToken = new StringTokenizer(lin);
 
				while (ligneToken.hasMoreTokens()) 
				{
					System.out.println("ça marche!!");
					mot = (ligneToken.nextToken());
					System.out.println(mot);
 
					if(p.contientMot(mot.toLowerCase()))
						System.out.println("ça marche!! Mot trouvé : "+mot);
					else
						System.out.println("ça marche pas!! Mot non trouvé : "+mot);
				}              
			}
		br.close();
		}
		catch (Exception e)
		{
		}
	}
}

Encore merci.

[jerofr]

En fait j'aurais dû être un peu plus précis.

Le premier fichier c’est pour construire l’arbre, on lit le fichier, puis on parcourt le fichier mot à mot pour construire au fur et à mesure l’arbre à lettres. (p.ajouterMot(mot.toLowerCase())).

Ensuite on compare l’autre fichier au contenu de l’arbre construit avec le fichier précédent. Pour chaque mot, on appelle la méthode contientMot et retourne vrai si le mot appartient au lexique(p.contientMot(mot.toLowerCase())).

En ce qui concerne l’instance, elle indique le premier caractère et l’arraylist indique une liste des caractères suivants. Dans le main, on voit le A qui sera la racine. Donc ici tous les mots commenceront par A.
ALettre p;
p = new ALettre('A');
Mais juste pour donner un exemple.
Si je remplace le A par S et si j’ai les 4 mots ci-dessous:
Soleil
Salir
Somme
Sommes

J’aurai ça:
A * L * I * R °
*
S * O* L * E * I * L°
*
M
*
M
*
E
°
S
°

Les * sont les nœuds et les ° les nœuds de fin de mot.

Encore merci.

[Djakisback]

Salut,
je n'ai pas encore tout lu mais je pense que ça ne sert à rien d'ajouter un caractère de fin de mot :

Code :

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

1
2
3
boolean isFinDeMot() {
return (this.lettresSuivantes == null);
}

Et dans constructeur t'initialises lettresSuivantes = null;
Comme ça tu crées tes ArrayList au fur et à mesure pour préserver la mémoire.

[Edit] Ok, je viens de voir que ça ne fonctionnera pas pour Somme et Sommes

[bigbear19]

Bon, après quelques essais, je te propose cette fonction. Peut-être qu'il te faudras un peu l'adaptée. N'hésite pas à me dire si tu rencontres d'autres problèmes.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public void ajouterMot(ALettre l, String mot) {
	if (mot.length() == 1) {
		l.setFinDeMot(true);
		return;
	}
	if (mot.charAt(0) == l.lettre) {
		char c = mot.charAt(1);
		if (!contientLettre(c)) {
			ajouterLettre(c);
		}
		ajouterMot(getSousArbre(c), mot.substring(1));
	}
}

[jerofr]

Salut!
Merci beaucoup pour ton aide!
Dans ta méthode tu appelle la méthode ajouterLettre. Celle-ci n'existe pas, je ne l'ai pas créé. Est-ce qu'il y a un moyen de faire en sorte que cela fonctionne sans utiliser cette nouvelle méthode?

Encore merci.