INF 220 – JAVA (CORRIGÉ DU TD2)

Ce corrigé de TD en Java porte sur la conception de fonctions, la définition de structures de données et la manipulation de listes chaînées. Il évalue la capacité à définir des signatures de fonctions adaptées, à modéliser des classes, et à manipuler des structures dynamiques comme les listes chaînées en Java.

1 PETITE MISE EN ROUTE

Dans cette partie, il s'agit de définir les entêtes de fonctions Java, c’est-à-dire leurs paramètres et leurs types de retour, en fonction de la tâche demandée.

1. Fonction qui retourne le plus grand élément d'un tableau de double.

   On cherche une fonction qui prend un tableau de double en paramètre et retourne un double, le plus grand élément.

   public static double plus_grand_element(double[] t)

   Réponse : La fonction retourne un double et prend en paramètre un tableau de double.

2. Fonction qui trie un tableau d'entiers.

   La fonction doit trier un tableau d'entiers donné en paramètre. Elle ne retourne rien car elle modifie le tableau en place.

   public static void trier(int[] t)

   Réponse : La fonction prend un tableau d'entiers en paramètre et ne retourne rien (void).

3. Fonction qui calcule la racine carrée d'un entier.

   La fonction prend un entier en paramètre et retourne un double correspondant à la racine carrée.

   public static double racine(int x)

   Réponse : La fonction prend un entier et retourne un double.

4. Fonction qui fusionne deux tableaux d'entiers.

   La fonction prend deux tableaux d'entiers en paramètres et retourne un nouveau tableau d'entiers contenant la fusion.

   public static int[] fusion(int[] t1, int[] t2)

   Réponse : La fonction prend deux tableaux d'entiers et retourne un tableau d'entiers.

5. Fonction qui renvoie la moyenne des éléments d'un tableau d'entiers.

   La fonction prend un tableau d'entiers en paramètre et retourne un double correspondant à la moyenne.

   public static double moyenne(int[] tabulo)

   Réponse : La fonction prend un tableau d'entiers et retourne un double.

public static int puissance(int x, int n)

public static boolean rechercher(int[] tab, int x)

public static void decomposition(int x)

public static int[] decomposition(int x)

public static CartePokemon fusion(CartePokemon p1, CartePokemon p2)

2 ÉLABORER UNE STRUCTURE DE DONNÉES

Il s'agit ici de définir des classes Java correspondant à des structures de données pour gérer des élèves et des classes.

1. Définir une structure pour suivre un élève avec son nom, prénom et ses notes en informatique, maths et anglais.

   La classe Eleve contient des champs String pour nom et prénom, et des doubles pour les notes.

   class Eleve
   {
       String nom;
       String prenom;
       double note_anglais;
       double note_info;
       double note_maths;
   }

   Réponse : La classe Eleve est définie avec les champs demandés.

2. Définir une structure pour gérer une classe d'élèves, avec le nombre d'élèves, la promotion et un tableau d'élèves.

   La classe Classe contient un entier promo, un entier nb_eleve, et un tableau d'Eleve.

   class Classe
   {
       int promo;
       int nb_eleve;
       Eleve[] tous_les_eleves;
   }

   Réponse : La classe Classe est définie avec les champs demandés.

3 SAUVEZ-LES TOUS !

Cette partie traite de la manipulation d'une liste chaînée de Pokemons, avec des opérations classiques : suppression, ajout, accès, taille.

1. Quel élément permet de retrouver tous les autres éléments de la liste ?

   La tête de la liste, c’est-à-dire le premier élément, permet d'accéder à tous les autres en suivant les liens "suivant".

   Réponse : La tête de la liste, caractérisée par le fait qu'aucun autre élément ne pointe vers elle.

2. Comment supprimer un élément de cette liste ?

   On peut supprimer un élément en connaissant soit le Pokemon à supprimer, soit sa position dans la liste. On parcourt la liste jusqu'à l'élément précédent, puis on modifie son lien "suivant" pour sauter l'élément à supprimer.

   Le code suivant illustre la suppression selon la position :

   public static void supprimer(Pokemon tete_liste, int position)
   {
       Pokemon parcours;
   
       if(position==0) // suppression du premier élément
       {
           tete_liste.nom = tete_liste.suivant.nom;
           tete_liste.puissance = tete_liste.suivant.puissance;
           tete_liste.type = tete_liste.suivant.type;
           tete_liste.suivant = tete_liste.suivant.suivant;
       }
       else
       {
           parcours = tete_liste;
           for(int i=0; i!=position-1; i=i+1)
           {
               parcours = parcours.suivant;
           }
           parcours.suivant = parcours.suivant.suivant;
       }
   }

   Réponse : On supprime en modifiant les liens "suivant" pour exclure l'élément ciblé.

3. Et si la liste est triée ?

   La méthode de suppression ne change pas, on supprime de la même façon.

   Réponse : La suppression est identique, la structure triée ne modifie pas la méthode.

4. Comment ajouter un élément à la liste ?

Pour ajouter un élément à la fin de la liste, on parcourt la liste jusqu'au dernier élément (celui dont "suivant" est null), puis on lui affecte le nouvel élément.

public static void ajouter_a_la_fin(Pokemon tete_liste, Pokemon a_rajouter)
{
    Pokemon parcours = tete_liste;
    while(parcours.suivant != null)
    {
        parcours=parcours.suivant;
    }
    parcours.suivant = a_rajouter;
    a_rajouter.suivant=null;
}

Réponse : On parcourt jusqu'à la fin et on ajoute le nouvel élément.

public static int taille_liste(Pokemon tete_liste)
{
    int taille=0;
    Pokemon parcours = tete_liste;
    while(parcours != null)
    {
        parcours=parcours.suivant;
        taille = taille+1;
    }
    return taille;
}

class GestionnaireListe
{
    int taille_liste;
    Pokemon tete_liste;
}

public static Pokemon acces(Pokemon tete_liste, int position)
{
    Pokemon parcours=tete_liste;
    for(int i=0; i!=position; i=i+1)
    {
        parcours=parcours.suivant;
    }
    return parcours;
}

Méthode

Ce TD récompense la capacité à raisonner clairement sur la définition des signatures de fonctions, en identifiant correctement les paramètres et types de retour selon la tâche. Il valorise aussi la modélisation simple de classes pour représenter des données structurées.

Pour la manipulation des listes chaînées, il faut démontrer la compréhension des liens entre éléments, savoir parcourir la liste, et modifier les pointeurs pour ajouter ou supprimer des éléments. La rigueur dans la gestion des cas particuliers (comme la suppression du premier élément) est essentielle.

Les erreurs fréquentes sanctionnées sont :

• Confondre le type de retour ou les paramètres d'une fonction.
• Oublier de traiter le cas particulier de la tête de liste lors de la suppression.
• Ne pas parcourir correctement la liste pour accéder ou modifier un élément.
• Ne pas mettre à jour les liens "suivant" lors des opérations sur la liste.
• Confondre la complexité d’accès entre liste chaînée et tableau.

La clarté du raisonnement, la précision dans la syntaxe Java et la gestion des cas particuliers sont donc des points clés pour réussir ce type d'exercice.