Bonjour,

j'aurais besoin d'aide pour le problème suivant.

Je dois créer une fonction qui lit une chaine de caractère et construit autant d'arbre que possible.

Par exemple :

si la chaine que j'entre est: + 1 2 - * 3 7 x

la fonction doit me créer 2 arbres: + 1 2 et - * 3 7 x.

J'ai crée la fonction que voici qui me permet de créer un arbre mais comment faire pour en créer plusieurs?

Edited December 21, 200520 yr by Morpheus75

Bonjour

Bonjour

j'aurais besoin d'aide pour le problème suivant.

Oui ?

Voici le code:

Et ?

Si tu disais ce que tu veux qu'on y trouve dans ton code, ce qui fonctionne et ce qui ne fonctionne pas...

Pour ton algo, je dirais que tu t'arrêtes à chaque fois que tu as dépassé n+1 nombres (avec n ton nombre d'opérateurs précédents).

Tu peux parser avant de passer ta chaine ou alors carrément vérifier que tous tes opérateurs on bien tous deux sous arbres lors du remplissage.

Juste quelques petites remarques :

Tu peux remplacer ça

struct noeud{
 enum Type type;
 union Info info;
 struct noeud *gauche;
 struct noeud *droit;
};
typedef struct noeud Noeud;
typedef struct noeud * Expression; 

par ça :

struct noeud{
 enum Type type;
 union Info info;
 struct noeud *gauche;
 struct noeud *droit;
} Noeud;
typedef struct noeud * Expression; 

Et aussi ça :

  else
{
  /* c'est une lettre */
  if(isalpha(**ligne))
{

Par

else  if(isalpha(**ligne))
{

Pourquoi tu as abandonné ton isalpha ici :

  while( (*place != '\0') && (*place != ' ') )

?

Si on suppose que tu parse avant, c'est plus simple :

On reprend ta chaine : "1 * + 1 2 x + 1 y"

Tu lis le début de la chaine, tu as un '1', donc 0 opérateur et un opérande. Tu est arrivé à ton n+1. Tu peux passer la chaine "1" à ta fonction.

Ensuite tu as * (1 opérateur et 0 opérande, 0<1+1), + (2 opérateurs et 0 opérande, 0<2+1), 1 (2 opérateurs et 1 opérande, 1<2+1), 2 (2 opérateurs et 2 opérandes, 2<2+1), x (2 opérateurs et 3 opérandes, 3=2+1)

Tu as ton bon nombre d'opérande, fin du parsage, tu copie * + 1 2 x dans un buffer et tu passe ça à ta fonction.

Pareil pour + 1 y

Ok, alors un truc du genre :

debut=fin=0
operande=operateur=0
Tant que (pas fin de chaine)
Tant que (opérateur + 1 > opérande)
	 si prochain élément = opérateur
		  operateur++
	 sinon si prochain élément = opéraande
		  operande++
fin++
Fin Tant que (donc on arrive à opérateur +1 = opérande)
copier (entre début et fin) dans buffer
Créer un nouvel arbre /*(un pointeur)*/
nouvel arbre = AnalyseExpression(buffer);
debut=fin
Fin Tant que

C'est pas très très clair

Pour le prototype de la fonction,tu proposes de mettre le meme que celui que j'ai crée ou bien un autre.

Ben c'est le même vu que c'est ta fonction que j'appelle.

Concernant les différents arbres qui seront crées ,comment faire pour les mémoriser dans un tableau d'arbres ? (car il me semble que tu ne l'a pas indiqué ,à moins que je ne l'ai pas vu )

Expression e[taille] ou fait une liste chainée.