Mettre une expression arithmétique sous forme d'un arbre puis la calculer en JAV [Résolu]

Messages postés
25
Date d'inscription
mercredi 24 novembre 2010
Dernière intervention
17 janvier 2014
- - Dernière réponse : cs_Julien39
Messages postés
6450
Date d'inscription
mardi 8 mars 2005
Dernière intervention
17 mai 2018
- 1 mai 2011 à 08:53
Salut tous le monde!!!
j'ai un problème je n'arrive pas a mettre une expression arithmétique sous la forme d'un arbre puis la calculer (JAVA).Si quelqu'un peut m'aider ça serait très gentil :)
je vous remercie par avance :)
Afficher la suite 

Votre réponse

3 réponses

Meilleure réponse
Messages postés
25
Date d'inscription
mercredi 24 novembre 2010
Dernière intervention
17 janvier 2014
3
Merci
merci bcp mais j'arrive pas a comprendre ton code en plus ya la classe IArbre qui manque :o
merci bien de me répondre vite les mecs :))

Merci cs_Aymanovitch 3

Quelques mots de remerciements seront grandement appréciés. Ajouter un commentaire

Codes Sources a aidé 103 internautes ce mois-ci

Commenter la réponse de cs_Aymanovitch
Messages postés
6450
Date d'inscription
mardi 8 mars 2005
Dernière intervention
17 mai 2018
0
Merci
J'ai fait ce programme il y a un moment, je te donne le code source de l'analyseur, sachant que j'avais utilisé le design pattern composite pour les branches de l'arbre, je pense que c'est ce que tu as fais aussi, si ce n'est pas le cas, tu vas avoir du mal à t'en sortir.

Je te laisse adapter ce code à ton programme
package metier.analyseur;

import java.util.ArrayList;
import java.util.List;

import metier.arbre.ArbreFactory;
import metier.arbre.IArbre;
import metier.composant.IComposant;
import metier.composant.noeud.NoeudFactory;
import metier.composant.operande.Constantes;
import metier.composant.operande.OperandeFactory;
import metier.composant.operateur.IOperateur;
import metier.composant.operateur.OperateurFactory;
import metier.composant.operateur.TypeOperateur;
import metier.composant.operateur.fonction.FonctionFactory;
import metier.composant.operateur.fonction.IFonction;
import metier.composant.operateur.fonction.TypeFonction;
import exception.EquationIncorrecteException;
import exception.ValeurIncorrecteException;

/**
 * Classe définissant les fonctions d'analyse d'une chaine de caractères
 * 
 * @author Julien
 *
 */
public class Analyse {

/**
 * Effectue la calcul
 * @param s
 * @return
 */
public double calculer(String s){
return creerArbre(s).calculer();
}

/**
 * Créé l'arbre correspondant à l'équation
 * @param equation : equation a calculer
 * @return l'abre
 */
private IArbre creerArbre(String equation){
IComposant racine=null;
try {
racine = creerNoeudRacineSimple(equation);
} 
catch (EquationIncorrecteException e) {
e.printStackTrace();
}
return ArbreFactory.getInstance().getArbre(racine);
}

private IComposant creerNoeudRacineSimple(String equation) throws EquationIncorrecteException{
IComposant res=null;
if(isNumber(equation)){
res = OperandeFactory.getInstance().getOperande(equation);
}
else {
List indices = rechercherIndiceOperateur(equation, 0, true);
List listeOperateurs = rechercherOperateur(equation, indices);
if(indices.size()==0){
indices = rechercherIndiceOperateur(equation, 0, false);
listeOperateurs = rechercherOperateur(equation, indices);
}
if(indices.size()==0){
if(getFonction(equation)==null){
res=creerNoeudRacineSimple(equation.substring(1, equation.length()-1));
}
else{
IFonction fonction = getFonction(equation);
res=NoeudFactory.getInstance().getNoeud(
fonction,
creerNoeudRacineSimple(
equation.substring(fonction.getNbLettres()+1, equation.length()-1))
);
}
}
else{
int k=0;
for(int i=0; i<listeOperateurs.size(); i++){
if(listeOperateurs.get(i).getType()==TypeOperateur.Multiplication || listeOperateurs.get(i).getType()==TypeOperateur.Division){
k=i;
}
}
res=NoeudFactory.getInstance().getNoeud(
listeOperateurs.get(k),
creerNoeudRacineSimple(equation.substring(0, indices.get(k))),
creerNoeudRacineSimple(equation.substring(indices.get(k)+1, equation.length()))
);
}

}
return res;
}

/**
 * Fonction retournant vrai si le paramètre est un nombre
 * @param s
 * @return
 */
private boolean isNumber(String s){
boolean res=true;
for(int i=0; i<s.length(); i++){
if(!"1234567890.".contains(s.charAt(i)+"")){
res=false;
}
}
for(Constantes c : Constantes.values()){
if(s.equals(c.name())){
res=true;
}
}
return res;
}

/**
 * Fonction permettant de récupérer une fonction dans une chaine
 * @param s
 * @return
 */
private IFonction getFonction(String s){
IFonction f = null;
for(TypeFonction t : TypeFonction.values()){
if(t.getSymbole().length()<s.length() && s.substring(0, t.getSymbole().length()).equals(t.getSymbole())){
f=FonctionFactory.getInstance().getFonction(t);
}
}
return f;
}

/**
 * Fonction qui donne le nombre de parentheses ouvertes et non refermées
 * @param indice
 * @param eq
 * @return
 */
private int getNiveau(int indice, String eq){
int niveau=0;
for(int i=0; i rechercherIndiceOperateur(String equation, int niveau, boolean justeNP){
List liste = new ArrayList();
for(int i=0; i<equation.length(); i++){
for(TypeOperateur t : TypeOperateur.values()){
if(equation.charAt(i)==t.getSymbole() && getNiveau(i, equation)==niveau){
if(!justeNP || !t.isPrioritaire()){
liste.add(i);
}
}
}
}
return liste;
}

/**
 * Fonction qui recherche les opérateurs dans une chaine
 * @param equation
 * @param indices
 * @return
 */
private List rechercherOperateur(String equation, List indices){
List liste = new ArrayList();
for(Integer i : indices){
try {
liste.add(OperateurFactory.getInstance().getOperateur(TypeOperateur.getTypeOperateurBySymbole(equation.charAt(i))));
} 
catch (ValeurIncorrecteException e) {
e.printStackTrace();
}
}
return liste;
}
}
Commenter la réponse de cs_Julien39
Messages postés
6450
Date d'inscription
mardi 8 mars 2005
Dernière intervention
17 mai 2018
0
Merci
Si tu n'avais pas accepté ta propre réponse, j'aurais répondu plus vite, je croyais que ma réponse t'avait suffit.

Donc, ton probleme n'est pas uniquement de mettre ton expression sous forme d'arbre mais aussi de créer l'arbre.

J'ai codé tout ca il y a un moment et je l'ai posté sur ce site, mais attention, je n'ai pas géré les exceptions dans le code, donc si tu utilises mon code dans le cas ou ton équation est correcte ca ira sinon tu verra une erreur dans ta console.

Mon code permet de mettre une équation sous forme d'arbre binaire, chaque noeud représenté un opérateur. Il prend en compte les priorités, les parenthèses, et certaines operations (cosinus, sinus, exponentielle,...). L'arbre utilise le design pattern composite (fait une recherche sur google).

Attention, c'est un code d'un niveau de difficulté assez important :
http://www.javafr.com/codes/ANALYSEUR-SYNTAXIQUE-EQUATIONS_52495.aspx
Commenter la réponse de cs_Julien39

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.