Enregistrement

Introduction

Dans une application de géométrie nous manipulons des points et des vecteurs.

Dans toutes les applications supposant la résolution de systèmes d’équations linéaires, nous manipulons des vecteurs et des matrices.

Dans une application de gestion de la scolarité nous manipulons des étudiants et des matières.

Dans une application de gestion commerciale nous manipulons des produits, des clients et des fournisseurs.

Pas des données simples

Ce sont des données complexes

Exemples

Un point p se définit par un couple (x,y) si on est dans le plan et par un n-uplet \((x_1,...,x_n)\) si on est dans un espace de dimension n.

Un vecteur de Rn se définit par un n-uplet \((x_1, ..., x_n)\) de réels.

Une matrice à n lignes et m colonnes se définit par m n-uplets \((x_{i1},...,x_{in})\) de réels.

Un étudiant est défini, par exemple, par un nom, un prénom et une année d’études.

Un produit est défini, par exemple, par un code et un libellé.

Un client (ou un fournisseur) est défini, par exemple, par un code, un nom et une adresse.

Définition et déclaration

Définition

Enregistrement nomEnregistrement
    nomChampsA: typeChampsA
    nomChampsB: typeChampsB
    ...
    nomChampsX: typeChampsX
FinEnregistrement

Déclaration d’une variable

Variables
    nomVariable: nomEnregistrement
FinVariables

Exemple

Enregistrement Produit
    reference: Entier
    nom: Texte
FinEnregistrement

Exercice

Tableaux d’enregistrements

1. Définir un enregistrement destiné à décrire un étudiant à l’aide de son nom, son prénom et sa moyenne.
2. Écrire un algorithme permettant de calculer et d’afficher les moyennes d’un groupe de 3 étudiants. Pour cela on procédera comme suit :
   1. Le nombre de notes nbnotes sera fixé à 2 et pour chaque étudiant on calculera la moyenne,
   2. pour chaque étudiant, le programme fixera les nbnotes obtenues, ensuite l’algorithme calcule la moyenne de cet étudiant,
   3. à la fin l’algorithme affiche pour chaque étudiant son nom, son prénom et sa moyenne.

G1

Enregistrement Etudiant
    nom: texte
    prenom: texte
    moyenne: flottant
FinEnregistrement

Variables
    etudiants : tableau de 20 étudiants
    nbnotes, e, i: entier
    somme: flottant
    note: flottant
FinVariables
Debut
    Lire(nbnotes)
    Pour e allant de 1 à 20
        somme <- 0
        Ecrire("Etudiant: " & etudiants[e].nom
            & " " & etudiants[e].prenom)

        Pour i allant de 1 à nbnotes
            Ecrire("Saisir note:")
            Lire(note)
            somme <- somme + note
        FinPour
        etudiants[e].moyenne <- somme / nbnote
    FinPour
Fin

class Etudiant {
    String nom;
    String prenom;
    double moyenne;
}

public class MoyennesEtudiants {
    double saisirFlottant(String message) {return 0.0; }
    int saisirEntier(String message) {return 0; }

    void saisirNotes(Etudiant[] etudiants, int nbnotes) {
        for(int e = 0 ; e < etudiants.length; e++){
            double somme = 0.0;
            System.out.println("Etudiant: "+ etudiants[e].nom+
                    " "+ etudiants[e].prenom);
            for(int i = 0 ; i < nbnotes; i++){
                double note = saisirFlottant("Saisir note: ");
                somme += note;
            } // FinPour
            etudiants[e].moyenne = somme / nbnotes;
        }
    }
}

import java.util.Scanner;

class Etudiant {
    String nom;
    String prenom;
    double moyenne;
}

public class MoyennesEtudiants {
    public static void main(String[] args) {
        Etudiant[] listeEtudiants = new Etudiant[3];
        listeEtudiants[0] = new Etudiant();
        listeEtudiants[0].prenom = "Aya";
        listeEtudiants[0].nom = "Nakamura";
        listeEtudiants[1] = new Etudiant();
        listeEtudiants[1].prenom = "Nej";
        listeEtudiants[1].nom = "Nej";
        listeEtudiants[2] = new Etudiant();
        listeEtudiants[2].prenom = "Freddy";
        listeEtudiants[2].nom = "Mercury";
        int nbnotes = saisirEntier("Donner le nombre de notes à saisir:");
        saisirNotes(listeEtudiants, nbnotes);

    }


    static void saisirNotes(Etudiant[] etudiants, int nbnotes) {
        for(int e = 0 ; e < etudiants.length; e++){
            double somme = 0.0;
            System.out.println("Etudiant: "+ etudiants[e].nom+
                    " "+ etudiants[e].prenom);
            for(int i = 0 ; i < nbnotes; i++){
                double note = saisirFlottant("Saisir note: ");
                somme += note;
            } // FinPour
            etudiants[e].moyenne = somme / nbnotes;
        }
    }

    static double saisirFlottant(String message) {
        System.out.println(message);
        Scanner scanner = new Scanner(System.in);
        double valeur = scanner.nextDouble();
        scanner.close();
        return valeur;
    }
    static int saisirEntier(String message) {
        System.out.println(message);
        Scanner scanner = new Scanner(System.in);
        int valeur = scanner.nextInt();
        scanner.close();
        return valeur;
    }

}

G2

Enregistrement Etudiant
    nom: Texte
    prenom: Texte
    moyenne: flottant
FinEnregistrement

Variables
    nbnotes: entier
    etudiant: Etudiant
    etudiants: tableau de 3 Etudiant
FinVariables
Debut
    nbnotes <- 2
    etudiant <- créer Etudiant
    etudiant.nom <- "Nakamura"
    etudiant.prenom <- "Aya"
    etudiant.moyenne <- (15 + 6.5) / nbnotes
    etudiants[0] <- etudiant
    
    etudiant <- créer Etudiant
    etudiant.nom <- "Mercury"
    etudiant.prenom <- "Freddy"
    etudiant.moyenne <- (12 + 11.5) / nbnotes
    etudiants[1] <- etudiant

    etudiants[2] <- créer Etudiant
    etudiants[2].nom <- "Torres"
    etudiants[2].prenom <- "Leonie"
    etudiants[2].moyenne <- (16 + 14.5) / nbnotes
    
    Pour i allant de 0 à 2
        AFFICHER(etudiants[i].nom & " "
            etudiants[i].prenom & " "
            etudiants[i].moyenne)
    FinPour
Fin

class Etudiant {
    String nom;
    String prenom;
    double moyenne;
}

public class DemoEtudiant {
    public static void main(String[] args) {
        int nbnotes = 2;
        Etudiant etudiant ;
        Etudiant[] etudiants = new Etudiant[3];
        
        etudiant = new Etudiant();
        etudiant.nom = "Nakamura";
        etudiant.prenom = "Aya" ;
        etudiant.moyenne = (15 + 6.5) / nbnotes ;
        etudiants[0] = etudiant;
        
        etudiant = new Etudiant();
        etudiant.nom = "Mercury";
        etudiant.prenom = "Freddy" ;
        etudiant.moyenne = (12 + 11.5) / nbnotes ;
        etudiants[1] = etudiant;
        
        etudiants[2] = new Etudiant();
        etudiants[2].nom = "Torres";
        etudiants[2].prenom = "Leonie";
        etudiants[2].moyenne = (16 + 14.5) / nbnotes;
        
        for (int i = 0 ; i < etudiants.length; i++) {
            System.out.println(etudiants[i].nom 
                    + " " + etudiants[i].prenom + " "+
                    etudiants[i].moyenne);
        }   
    }
}

Les files

Structure de données

Utilisation des enregistrements

Enregistrement Element
    valeur: Texte
    suivant: Element
FinEnregistrement

Enregistrement Pile
    tete: Element
FinEnregistrement

Fonctions associées

Créer les fonctions correspondantes:

File creerFile()
Element enfiler(valeur:Texte, file: File)
booléen estVide(file: File)
Element defiler(file: File)

Fonction creerFile()

Créer une file vide.

Renvoie un enregistrement vers la file créée

Fonction enfiler(valeur:Texte, file: File)

Stocke la valeur donnée dans un nouvel élément

Place cet élément en fin de la file passée en paramètre

Fonction estVide(file: File)

Indique si la file passée en paramètre est vide ou non

Fonction defiler(file: File)

Renvoie le premier élément ajouté dans la file

Supprime cet élément de la pile

Listes chainées

Liste chaînée simple

Structure de données

Enregistrement Element
    valeur: Texte
    prochain: Element
FinEnregistrement

Enregistrement Liste
    premier: Element
FinEnregistrement

Fonctions correspondantes

creerListe(): Liste
trouver(index: entier, liste: Liste) : Element
taille(liste: Liste) : Entier
ajouter(liste:Liste, valeur : Type Valeur) // à la fin
inserer(liste:Liste, index: Entier, valeur : Type Valeur)
supprimer(index: Entier, liste: Liste)
vider(liste: Liste)

Exercices

Manipulation des piles, des files et des listes

1. Écrire une procédure permettant d’inverser l’ordre des éléments d’une pile (resp. une file).
2. Écrire une fonction permettant de calculer le nombre d’éléments d’une pile (resp. une file, une liste).
3. Écrire une procédure permettant d’insérer un élément à la ieme posi- tion d’une pile (resp. une file, une liste).
4. Écrire une procédure permettant de supprimer un élément d’une pile (resp. une file, une liste). — Plusieurs variantes : l’élément est donné par sa valeur ou par sa position, on supprime une occurence ou toutes les occurences.
5. Écrire une fonction permettant de chercher un élément dans une pile (resp. une file, une liste).
6. Expliquer comment on peut simuler une pile à l’aide de deux files et inversement.