Discussion :

[kylan]

bonjour!
j'essaie de parcourir une liste chainée afin de placer un élement en fonction de sa priorité cette classe implément un iterateur .
mon problème c'est que je ne sais pas comment obtenir la priorité de l'element suivant afin de la comparer avec la priorité de mon element courant.
voici ce que j'ai écrit jusque la

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
 
 
 
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
 
import ca.uqam.inf2120.tp2.adt.FileAttenteTda;
import ca.uqam.inf2120.tp2.adt.OrdonnableParPrioriteEtDateHeure;
 
public class FileAttenteChaineeImpl<T extends OrdonnableParPrioriteEtDateHeure>
implements FileAttenteTda<T>{
	private Noeud<T> debut=null;
	private Noeud<T> fin=null;
	private int taille=0;
	FileAttenteChaineeImpl<T> file;
	//constructeur vide sans parametre
	public FileAttenteChaineeImpl(){
 
 
    }
 
 
 
 
 
 
	 /*
	  * redefinition de la methode iterator();cette methode retourne un objet iterator
	  * <T> a travers lequel on peut parcourir notre file d'attente pour appliquer 
	  * des traitements specifiques sur les membres qu'elle contient
	  * 
	  * */
	 	@Override
	 	 public Iterator<T> iterator() {
	          return new FileAttenteImplIterator();
	     }
 
	// Classe interne privÈe pour l'implantation de l'itÈrateur
 
private class FileAttenteImplIterator implements Iterator<T> {
 
	 private Noeud<T> courant=null;
 
 
          public FileAttenteImplIterator() {
              courant=debut;
          }
          @Override
          public boolean hasNext() {
 
                return courant!=null;
 
          }
 
          @Override
          public T next() {
        	  System.out.println("allo");
              if ( courant==null ) throw new NoSuchElementException();
                T element = courant.getElement();
                courant = courant.getSuivant();
                return element;
 
          }
          @Override
          public void remove() {
                throw new UnsupportedOperationException();       
         }
 
    }
 
 
 
	/**
         * Place l'ÈlÈment "elt" dans la file selon sa prioritÈ. Les ÈlÈments de la
         * plus grande prioritÈ sont placÈs au dÈbut de la file. Si "elt" a la mÍme
         * prioritÈ qu'un autre ÈlÈment qui existe dÈj‡ dans la file, il doit Ítre 
         * placÈ avant cet ÈlÈment si sa date / heure de crÈation est plus ancienne 
         * que ce dernier, sinon il est placÈ aprËs. L'ÈlÈment ne doit pas Ítre placÈ
         * dans la file  si une des conditions suivantes est vraie :
         *   - L'ÈlÈment est null.
         *   - L'ÈlÈment existe dÈj‡ dans la file (2 ÈlÈments identiques s'ils ont
         *     le mÍme identifiant).
         *   - La prioritÈ de l'ÈlÈment est infÈrieure ‡ 1.
         *
         * @param elt L'ÈlÈment ‡ ajouter
         * @return true si "elt" est ajoutÈ, sinon false
         */
	@Override
	public boolean placer(T elt) {
		//nouveau contenant l'element a placer dans la file
		Noeud<T> nouveau = new Noeud<>( elt);
		boolean placer =false;
		// Parcourir pour trouver le noeud cible dans la liste
		while (elt != null&& !placer && elt.obtenirPriorite()>1 ) 
		{
			placer=true;
 
			 if ( debut==null ) debut=new Noeud<T>(elt);
		else{
		// Création et initialisation du noeud temporaire
			Noeud<T> courant = debut;
			while(courant.getSuivant()!=null){
 
			//je suis blocqué  ici j'aimerai comparé la priorité de mon element a inseré
			//avec celle de l'element courant
				if( elt.obtenirPriorite().equals(elt.obtenirPriorite().getSuivant)
				//s'il ont la meme priorité je compare avec date de creation					
				if(elt.obtenirDateHeureCreation().before( file.get(i).obtenirDateHeureCreation())){
				}
 
			}

merci

[Gugelhupf]

Salut,

Tu peux utiliser l'interface Comparable pour ton type qui est "Ordonnable" "Par" "Priorite" "Et" "DateHeure", il ne te restera plus qu'à overrider la méthode compareTo. Cette méthode doit retourner :

• Entier négatif si this est "plus petit" que l'objet en paramètre
• 0 si this est est "égal" à l'objet en paramètre
• Entier positif si this est "plus grand" que l'objet en paramètre

Ex (pas compilé, mais dans l'idée) :

Code Java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
public class MonType implements Comparable<MonType> {
    int priority;
    LocalDateTime dateTime;
 
    @Override
    public int compareTo(MonType autreObjet) {
        if (this.priority == autreObjet.priority) {
            return (this.dateTime.isBefore(autreObjet.dateTime)) ? -1 : 1;
        } 
 
        return (this.priority > autreObjet.priority) ? -1 : 1;
    }
}

Tu peux ensuite trier/ordonner la liste :

Code Java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
List<MonType> list = new TonImplementationDeListe<>();
Collections.sort(list);

... Sauf si tu veux le faire à la main, élément par élément.


PS: Une liste chainée (ou doublement chainée d'après ton code) n'est peut-être pas la meilleure structure pour ton besoin, car une liste chainée implique un parcours complet.

A+

[kylan]

je n'ai pas vraiment le choix ,que d' utiliser un liste chainé et je ne peux changer non plus la signature de ma classe de depart. c'est dans le cadre d'un travail.
je comprends ton idée .mais vu que la priorité de l'element passé en paramètre ne m'est pas donné.
je pourrai dans le cadre d'un arraylist faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
elt.getPriorite()==uneListe.get(i).getPriorite())
//pour comparer mes deux priorités mais dans un linkedlist je sais pas comment aller chercher l'element a un indice donné

[joel.drigo]

Salut,

Je ne suis pas sûr de tout à fait comprendre le problème, mais j'ai l'impression que c'est un ListIterator qui te permettrait de réaliser ce que tu veux faire.

[plawyx]

pour trier la liste avec la méthode getPriorite() évoquée ci-dessus:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
 
Comparator<MonType> empComparator = Comparator.comparing(MonType::getPriorite);
 
Collections.sort(MonTypeListe, empComparator);
 
MonTypeListeList.forEach(System.out::println);  //affichage de la liste triée

[kylan]

vous avez bien raison je dois utiliser l'iterateur.
je l'ai utilisé pour parcourir ma liste chainée et comparé les priorités .afin de pouvoir placer mon element dans la liste chainée
mais je me demande si le collection.sort est approprié dans mon cas puisque je dois comparer aussi l'heure d'arrivé dans la file.
au cas ou mes deux priorité sont égaux .
merci pour vos réponses

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
 
@Override
	public boolean placer(T elt) {
 
		Noeud<T> courant = debut;
		boolean placer =false;
		// Parcourir pour trouver le noeud cible dans la liste
		if (elt != null&& !placer && elt.obtenirPriorite()>1 ) 
		{
			placer=true;
 
			 if ( debut==null ) debut=new Noeud<T>(elt);
			 Iterator<T> li= file.iterator();
			 //parcourt de ma file par l'iterator
				while (li.hasNext()) {
 
					T temp = li.next();
				if(elt.obtenirPriorite()==temp.obtenirPriorite())	
				{
		if(elt.obtenirDateHeureCreation().before(temp.obtenirDateHeureCreation()))			
		{
			// Créer un nouveau noeud avec l'élément à insérer
			Noeud<T> unNoeud = new Noeud<T>(elt);
			// Faire pointer le suivant du nouveau noeud sur
			// le suivant du noeud cible
			unNoeud.setSuivant(courant.getSuivant());
			// Faire pointer le suivant du noeud cible sur
			// le nouveau noeud
			courant.setSuivant(unNoeud);	
		placer=true;
		}
		}
				//si la priorité de l'element est inferieur 
     else if(elt.obtenirPriorite()>temp.obtenirPriorite())	
  {
    	// Créer un nouveau noeud avec l'élément à insérer
    				Noeud<T> unNoeud = new Noeud<T>(elt);
    				// Faire pointer le suivant du nouveau noeud sur
    				// le suivant du noeud cible
    				unNoeud.setSuivant(courant.getSuivant());
    				// Faire pointer le suivant du noeud cible sur
    				// le nouveau noeud
    				courant.setSuivant(unNoeud);	
    			placer=true;
					        }
				taille++;
					    }				
 
		}
		return true;	
 
 
 
 
 
		}

[joel.drigo]

Tu peux comparer selon plusieurs critères, en cascade :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Comparator.comparing(MonType::getCeci).thenComparing(MonType::getCela).thenComparing(...

Mais la question n'est pas là. Insérer un élement à un endroit précis dans une liste chainée, ou trier une liste, sont deux moyens d'obtenir le même résultat au final, mais deux moyens différents.