|
/* Supprime le dernier éléments pair de tab (de taille longueur) dans tab elle même */ |
| /* recherche du dernier entier pair */ |
| i <== longueur -1 |
| Tant que (tab[i] est impair) ET (i >= 0) |
|
i <== i -1 |
| fin_de_tantque |
| si i <> -1 /* la liste comporte bien au moins un élément pair */ |
| alors |
| /* suppression de l'élément en question */ |
|
Répéter pour j allant de i à longueur - 1 |
|
tab[j] <== tab[j+1] |
|
fin_de_répéter |
| longueur <== longueur - 1 |
Principe : A partir d'une suite d'entiers calculer la plus grande suite de nombres pairs contenue dans cette liste
Exemples :
| /* La liste tab de taille longueur */ |
| maxi <== 0 |
| i <== 0 |
| Répéter |
| compte <== 0 |
| /* Comptage des nombres pairs successifs */ |
| tant que (tab[i] est pair) ET (i < longueur) |
| compte <== compte + 1 |
| i<== i + 1 |
| fin_tant_que |
| /* Si cette suite de pairs est plus longue que la précédente */ |
|
si compte > maxi |
| alors maxi <== compte |
| i <== i + 1 |
| tant_que (i < longueur) |
Principe : Construire une nouvelle liste par insertion successive des éléments de la liste d'origine dans la liste résultat. La liste résultat commence donc avec un unique élement et reste en permanence triée.
La recherche de la place d'insertion se fait par un algorithme de recherche simple.
| mystere[0] <== tab[0] |
| lmystere <== 1 |
| Répéter pour i allant de 1 à longueur -1 |
| /* ?????????? */ |
| j <== 0 |
| tant que (tab[i] > mystere[j]) ET (j <lmystere) |
| j <== j + 1 |
| fin_tant_que |
| /* ?????????? */ |
| Répéter pour k allant de lmystere -1 à j par pas de -1 |
| mystere[k+1] <== mystere[k] |
| fin_de_répéter |
| mystere[j] <== tab[i] |
| lmystere <== lmystere + 1 |
| fin_de_répéter |
}/* La méthode mysterieuse est un tri par insertion simple */
public ListeEntier mysterieuse ()
{
int i, j, k, lmystere;
ListeEntier mystere = new ListeEntier(this.getDim());
mystere.elementsListe[0] = this.elementsListe[0];
lmystere = 1;
for( i = 1; i < this.getDim(); i ++)
{
/* Recherche de la place d'insertion */
j = 0;
while ((this.elementsListe[i]>mystere.elementsListe[j]) &&
(j<lmystere))
j++; /* Décalage des éléments de la liste */
for( k=lmystere-1; k >= j; k--)
mystere.elementsListe[k+1]=mystere.elementsListe[k];/* Insertion de l'element */
mystere.elementsListe[j]=this.elementsListe[i];
lmystere++;
}
return mystere;
}public class EssaiListes
{
public static void main(String[] args)
{
// Création de deux listes par la méthode au hasard
System.out.println("Une liste construite au hasard ");
ListeEntier has1 = new ListeEntier(10);
has1.randomListe(100); has1.affichage();// Appel de la méthode mysterieuse
ListeEntier L2;
L2 = has1.mysterieuse();
System.out.println("La liste apres la methode mysterieuse :");
L2.affichage();
for(;;);
}