Problème liste chaînée

Bonjour,

En fait j'ai réaliser une interface pour créer des organigrammes. Maintenant, je veux créer une liste chaînée afin de pouvoir avoir une structure qui me donnera l'ordre de chaque instruction à exécuter de l'organigramme. Le problème, c'est aussi d'une condition (losange) où il y a une branche "oui" et une branche "non". Je ne sais pas comment traiter ce cas dans ma liste chaînée. Chaque maillon de ma liste chaînée possède trois champs :
      -> Géométrie
      -> Graphe : suivantOui
      -> Graphe : suivantNon
suivantNon est toujours mis à null sauf quand on a une condition (losange), donc il ne pointe sur rien (sauf pour losange). Je ne sais pas comment faire dès que j'ai un losange.
Il faut que ce soit récursif car on peut avoir plusieurs conditions à la suite ou dans les branches...


Voici le code de la classe Graphe (pour les maillons) :

public class Graphe {
 
 protected Geometrie g;
 protected Graphe suivantOui;
 protected Graphe suivantNon;
 protected Graphe precedentOui;
 protected Graphe precedentNon;

 // Constructeur par recopie
 public Graphe(Geometrie g) {
  this.g = g;
  this.suivantOui = null;
  this.suivantNon = null;
  this.precedentOui = null;
  this.precedentNon = null;
 }
 
 // Retourne true si il y a un suivantOui à cette géométrie
 public boolean hasSuivantOui() {
  return suivantOui != null;
 }
 
 // Retourne true si il y a un suivantNon à cette géométrie
 public boolean hasSuivantNon() {
  return suivantNon != null;
 }
 
 // Retourne la géométrie
 public Geometrie getElement() {
  return g;
 }
 
 // Retourne l'élément suivantOui
 public Graphe getSuivantOui() {
  return suivantOui;
 }
 
 // Retourne l'élément suivantNon
 public Graphe getSuivantNon() {
  return suivantNon;
 }
 
 // Modifie le lien vers l'élément suivantOui
 public void setSuivantOui(Graphe graphe) {
  suivantOui = graphe;
 }
 
 // Modifie le lien vers l'élément suivantOui
 public void setSuivantNon(Graphe graphe) {
  suivantNon = graphe;
 }
 
 // Retourne l'élément précédentOui
 public Graphe getPrecedentOui() {
  return precedentOui;
 }
 
 // Retourne l'élément précédentNon
 public Graphe getPrecedentNon() {
  return precedentNon;
 }
 
 // Modifie le lien vers l'élément precedentOui
 public void setPrecedentOui(Graphe graphe) {
  precedentOui = graphe;
 }
 
 // Modifie le lien vers l'élément precedentOui
 public void setPrecedentNon(Graphe graphe) {
  precedentNon = graphe;
 }
 
 // Détruit un élément
 public void effacer() {
  g = null;
  suivantOui = null;
  suivantNon = null;
  precedentOui = null;
  precedentNon = null;
 }
 
 // Modifier l'élément de la géométrie
 public void setGeometrie(Geometrie g) {
  this.g = g;
 }
 
}


Voici le code de ma classe Liste (pour la liste chaînée) :

import java.util.*;

public class Liste {

 private Graphe tete;
 private Graphe queue;
 private int taille;
 private Panneau panel;
 
 public Liste(Panneau monPanel) {
  tete = null;
  queue = null;
  taille = 0;
  panel = monPanel;
 }
 
 // Ajouter un élément en fin de liste
    public void insererFin() {
     for (int i = 0; i < panel.getMemoire().getNumFormes(); i++) {
      if (taille == 0) {
       Graphe graphe = new Graphe(panel.getMemoire().getFirstVFormes());
       tete = graphe;
       queue = graphe;
       taille ++;
      } else if (taille >0) {
       if (queue.g.isLosange()) {
         // COMMENT TRAITER SUIVANTNON ????
        Fleche fOui = rechercherFlecheOui(queue.g);
        Graphe grapheOui =  new Graphe(fOui.g2);
        //Fleche fNon = rechercherFlecheNon(queue.g);
        //Graphe grapheNon =  new Graphe(fNon.g2);
        queue.setSuivantOui(grapheOui);
        //queue.setSuivantNon(grapheNon);
        grapheOui.setPrecedentOui(this.queue);
        grapheOui.setPrecedentNon(null);
        queue = grapheOui;
        taille ++;
       } else {
        Fleche f = rechercherFleche(queue.g);
        if (f != null) {
         Graphe graphe =  new Graphe(f.g2);
         queue.setSuivantOui(graphe);
         queue.setSuivantNon(null);
         if (f.g2.isRectangle()) {
          graphe.setPrecedentOui(this.queue);
          graphe.setPrecedentNon(null);
         }
         else if (f.g2.isEllipse()) {
          graphe.setPrecedentOui(this.queue);
          graphe.setPrecedentNon(null);
         }
         else if (f.g2.isLosange()) {
          graphe.setPrecedentOui(this.queue);
          graphe.setPrecedentNon(this.queue);
         }
         queue = graphe;
         taille ++;
        }
       }
      }
     }
    }
         
    // Retourne la flèche dont g est la géométrie de départ de la flèche
 public Fleche rechercherFleche(Geometrie g) {
  Vector vFleches = panel.getMemoire().getVFleches();
  Iterator it = vFleches.iterator();
  while (it.hasNext()) {
   Fleche f = (Fleche) it.next();
   if (f.g1 == g)
    return f;
  }
  return null;
 }
 
 // Retourne la flèche dont g est la géométrie de départ de la flèche
 public Fleche rechercherFlecheOui(Geometrie g) {
  Vector vFleches = panel.getMemoire().getVFleches();
  Iterator it = vFleches.iterator();
  while (it.hasNext()) {
   Fleche f = (Fleche) it.next();
   if (f.g1 == g && f.s == "Oui")
    return f;
  }
  return null;
 }
 
 // Retourne la flèche dont g est la géométrie de départ de la flèche
 public Fleche rechercherFlecheNon(Geometrie g) {
  Vector vFleches = panel.getMemoire().getVFleches();
  Iterator it = vFleches.iterator();
  while (it.hasNext()) {
   Fleche f = (Fleche) it.next();
   if (f.g1 == g && f.s == "Non")
    return f;
  }
  return null;
 }
 
 // Retourne le nombre d'éléments de la liste
 public int getTaille() {
  return taille;
 }
 
 // Retourne true si la liste est vide
 public boolean isEmpty() {
  return taille == 0;
 }
 
 // Afficher chaque instruction de l'organnigramme
 public void afficherOui() {
  Graphe g = tete;
  if (g != null) {
   System.out.println(g.g.s);
   while (g.getSuivantOui() != null) {
    g = g.getSuivantOui();
    System.out.println(g.g.s);
   }
  }
 }
 
}


Merci d'avance pour vos réponses et votre aide.