Bon, alors je répond. Voici le code
J'utilise la bibliothèque Borland (VCL)
Certaines lignes de l'entête sont peut-être inutiles.
J'utilise 2 classes de Borland
AnsiString, très voisin de string, mais il faut vérifier si le 1er caractère est de rang 0 ou de rang 1.
TList, c'est une liste de pointeurs.
La structure NOEUD définit le lattre concernée et un pointeur sur la liste éventuelle des fils. Ce pointeur existe toujours, mais la liste peut être vide.
Cette structure est traitée pas le compilateur comme une classe.
Elle comporte un constructeur qui crée la liste, et un destructeur.
J'ai fait quelque changements, par exemple la longueur du mot n'est pas passée en paramètre.
Pour être tout à fait franc, je n'ai pas compris le but de ce calcul, donc je ne peux pas vraiment vérifier qu'il est bon.
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
| #include <vcl.h>
#include <vcl\Classes.hpp>
#include <vcl\SysUtils.hpp>
#include <vcl\Windows.hpp>
#include <vcl\System.hpp>
#include <conio.h>
#include <stdio.h>
typedef struct NOEUD
{
char lettre;
TList *les_fils; // la liste des fils
NOEUD(char L)
{
lettre = L;
les_fils = new TList();
}
~NOEUD(){/* à faire*/}
}TabNOEUD;
typedef TabNOEUD* ptrNoeud;
int inserer_dans_arbre(unsigned int rang,
const AnsiString &v,
TList *racine)
{
int i=rang;
// i est la position dans le mot (rang)
// v est le mot
// racine est la racine du sous-ararbre dans lequel on insère
unsigned int k=v.Length();// k est la taille du mot
char Lettre=v[i];
int ir;
ptrNoeud it=NULL;
for ( ir=0; ir< racine->Count; ir++)
{
it=(ptrNoeud)racine->Items[ir];
if (it->lettre == Lettre) break;
}
if (ir < racine->Count)
{
if (++i < k && it != NULL)
inserer_dans_arbre(i, v, it->les_fils);
}
else
{//il n'y est pas
//////////////////////////////////////////////////////////////////////
ptrNoeud p=new NOEUD(Lettre); //c'est la partie couteuse
/////////////////////////////////////////////////////////////////////
racine->Add(p);
if (++i < k )
inserer_dans_arbre(i, v, p->les_fils);
}
return 0;
}
voidl Afficher(ptrNoeud noeud)
{
TList *Fils=noeud->les_fils;
if (Fils != NULL)
{
printf("\n Lettre=%c %d fils",noeud->lettre, Fils->Count );
for (int i=0; i<Fils->Count; i++)
{
ptrNoeud unFils =(ptrNoeud)Fils->Items[i];
Afficher(unFils);
}
}
}
int main(){
//On récupère la liste des mots. Ensuite on crée l'arbre comme suit
ptrNoeud arbreP = new NOEUD(0); // le premier niveau de noeuds
for (int i=0; i< 11; i++)
{
AnsiString v;
switch(i)
{
case 0: v="zero"; break;
case 1: v="un"; break;
case 2: v="deux"; break;
case 3: v="trois"; break;
case 4: v="lundi"; break;
case 5: v="mardi"; break;
case 6: v="mercredi"; break;
case 7: v="jeudi"; break;
case 8: v="ventredi"; break;
case 9: v="samedi"; break;
case 10: v="dimanche"; break;
}
inserer_dans_arbre(1, v, arbreP->les_fils);
// le premier caractères est 1 et non 0 pour un AnsiString
}
Afficher(arbreP);
while (!kbhit()); // ou system("pause");
return 0;
} |
La fonction kbhit() attend la frappe d'un caractère. On peut remplacer cette ligne pas "system("pause");
Envoyé par Pierre Dolez
Répondre avec citation
). En réalité, les données sont sous la forme de chaines d'entiers par exemple, 
A méditer: La solution la plus simple est toujours la moins compliquée
Partager