je dois définir une structure de données pour ranger des mots d'un texte avec leur occurence et la ligne et la colonne ou il se trouve et puis ensuite les afficher par ordre alphabétique ou par taille. je ne sais pas comment m'y prendre. j'ai défini la strucutre suivante mais bon elle n'est pas parfaite.  
 

 
désolé mais j'ai que du jpeg et pas de compte perso sur internet donc je peux pas modifier ça.

[jfdsdjhfuetppo]--Message édité par LordAnkou--[/jfdsdjhfuetppo]

* tu effaces ce topic  
 
* tu uppes ton premier
 
* tu sauves ce genre d'images en GIF et pas en jpeg BORDEL ...

une autre idée concernat le sujet initial ?

up !

bon, qu'on en finisse
 
donc, tu as un fichier texte :
 
1) tu veux lire tous ces mots, avec leur position (x, y) dans le texte
2) compter le nombre de fois qu'ils apparaissent
3) pouvoir les afficher par ordre alphabétique ou par taille
 
stratégie : bourrin pour commencer, inutile de compliquer. tu ne précises pas le langage, on va faire ça en C :
 
1) tu lis tous tes mots dans un tableau. tu commences simplement, un tableau statique de (par ex) 500 entrées d'une structure type :
 
struct word
{
  char name[100];
  int x, y;
  int len;
}
 
donc ton tableau :
 
word words[500];
 
j'assume que tu sais lire ton fichier puis remplir les structures. si non, dis-le.
 
2) on compte le nombre de fois qu'ils apparaissent : là c'est simple. on va en fait trier les mots, il suffira de parcourir le tableau pour compter le nombre d'occurences. tu utilises qsort() en définissant une fonction de comparaison en fonction de word.name, qq chose comme :
 
int sortWords(void* elem1, void* elem2)
{
  return strcmp(((word*)elem1)->name, ((word*)elem2)->name);
}
 
tu parcoures ensuite ton tableau, tu auras qq chose comme :
 
ascenseur
ascenseur
boîte
dans
le
le
le
montagne
montagne
 
etc. tant que words[i+1].len = words[i].len, c'est une occurence de + pour ce mot.
 
3) ordre alphabétique : réglé avec le premier qsort().
ordre par taille : réglé avec une seconde fonction de tri qui trie en fonction ... de la taille.
 
//
 
cet algo est bourrin et pas joli du tout. en attendant, fait déjà marcher ça.
 
maintenant, plusieurs optims / options :
 
* utiliser un arbre pour insérer les mots est une BIG MISTAKE, tu vois tu t'en sors pas d'ailleurs - ton arbre est construit en fonction d'un critère de tri et change complètement dès que tu changes de tri.
 
autre problème : ton arbre ne va pas être équilibré DU TOUT. dans ce cas-là, tu peux utiliser les splay trees ( http://www.google.com/search?sourc [...] play+trees ), ça devient juste tout de suite (beaucoup) plus compliqué.
 
soluce plus simple : la liste chaînée avec l'alloc d'un nouvel élément à chaque fois.
 
* occupation mémoire : dès que tu tombes sur deux mots identiques, tu as deux copies en mémoire.
 
solution : une hashtable qui recense les mots, une entrée de la liste chaînée contient alors une référence vers une entrée de la hashtable + position du mot.  
 
l'entrée de la hashtable contient alors la taille de la string + son nombre d'occurences. à chaque fois que tu tombes sur un mot, une méthode add() de la hashtable s'occupe de :
- créer le symbole s'il n'existe pas
- si oui, on incrémente son nombre d'occurrences.
 
* cette dernière solution est la plus souple. pour le tri, ça ne change pas grand chose : tu utilises toujours les entrées de la liste chaînée, la méthode de tri s'occupe de l'indirection dans la hashtable :
 
int sortWords(void* elem1, void* elem2)
{
  return strcmp(((word*)elem1)->hash->name, ((word*)elem2)->hash->name);
}