Noeud.java

public class Noeud {
    private String etiquette;
    private Noeud gauche;
    private Noeud droit;

    public Noeud(String etiquette, Noeud g, Noeud d){
        this.etiquette = etiquette;
        this.gauche = g;
        this.droit = d;
    }

    public Noeud(String etiquette){
        this(etiquette, null, null);
    }

    public Noeud(Noeud arbre){
        this.gauche = arbre.getGauche();
        this.droit = arbre.getDroit();
        this.etiquette = arbre.getEtiquette();
    }

    public Noeud getGauche() {return gauche;}
    public Noeud getDroit() {return droit;}
    public String getEtiquette() {return etiquette;}

    private static boolean estNombre(String x){
        return x.matches("[-+0-9][.0-9]*$");
    }

    public boolean verif(){
        if(estNombre(this.etiquette) || etiquette == "x"){
            return (gauche==null && droit==null); // les feuilles ne sont pas des opérateurs

        } else if (this.etiquette.equals("-")){
            return gauche.verif() || droit.verif();

        } else { // c'est forcément un opérateur +/*
            return gauche.verif() && droit.verif();
        }
    }

    public void afficheInfixe(){
        if(gauche != null){
            gauche.afficheInfixe();
        }
        System.out.print(etiquette + " ");
        if(droit != null){
            droit.afficheInfixe();
        }
    }

    public void afficheExpression(){
        System.out.print("(");
        if(gauche != null){
            gauche.afficheInfixe();
        }
        System.out.print(etiquette + " ");
        if(droit != null){
            droit.afficheInfixe();
        }
        System.out.print(")");
    }

    public double eval(){
        if(estNombre(etiquette)){
            return Double.parseDouble(etiquette);

        } else if (etiquette.equals("-")){
            if(gauche == null) return droit.eval()*(-1.0);
            if(droit == null) return gauche.eval()*(-1.0);
            return gauche.eval() - droit.eval();
            
        } else {
            switch(etiquette){
                case "+" : return gauche.eval() + droit.eval(); // breaks non nécessaires : return 
                case "*" : return gauche.eval() * droit.eval();
                case "/" : return gauche.eval() * droit.eval();    
            }
        }
        return 0.0; // javac ne compile pas sinon -_- Sans aucune raison !!!
    }

    public double evaluer(double z){
        if(estNombre(etiquette)){
            return Double.parseDouble(etiquette);

        } else if(etiquette.equals("-")){
            if(gauche == null) return droit.evaluer(z)*(-1.0);
            if(droit == null) return gauche.evaluer(z)*(-1.0);
            return gauche.evaluer(z) - droit.evaluer(z);
            
        } else if(etiquette.equals("x")){
            return z;
        } else {
            switch(etiquette){
                case "+" : return gauche.evaluer(z) + droit.evaluer(z);
                case "*" : return gauche.evaluer(z) * droit.evaluer(z);
                case "/" : return gauche.evaluer(z) * droit.evaluer(z);    
            }
        }
        return 0.0;
    }


    public Noeud simplifier(){
        /* Simple ? Définis simple */
        if(gauche != null){
            gauche = gauche.simplifier();
        }
        if(droit != null){
            droit = droit.simplifier();
        }
        if(estNombre(droit.getEtiquette()) && estNombre(gauche.getEtiquette())){
            return new Noeud(Double.toString(this.eval()), null, null);
        }
        return this;
    }

    public Noeud deriver(){
        if(estNombre(etiquette)){
            return new Noeud("0", gauche.deriver(), droit.deriver());

        } else if(etiquette.equals("x")){
            return new Noeud("1", gauche.deriver(), droit.deriver());
            
        } else if(etiquette.equals("-")){
            if(gauche == null) return new Noeud("-", null, droit.deriver());
            if(droit == null) return new Noeud("-", gauche.deriver(), null);
            else return new Noeud("-", gauche.deriver(), droit.deriver());

        } else if(etiquette.equals("+")){
            return new Noeud("+", gauche.deriver(), droit.deriver());

        } else if(etiquette.equals("*")){
            return new Noeud("+", new Noeud("*", gauche.deriver(), droit), new Noeud("*", gauche, droit.deriver())); // Nice le code, non ?

        } else {
            return new Noeud("/",
                         new Noeud("-",
                                 new Noeud("*", gauche.deriver(), droit),
                                 new Noeud("*", gauche, droit.deriver())),
                         new Noeud("*", gauche, gauche)
                         );
        }
    }
}