L’Ecole Centrale Supérieure Privée d’Informatique et des

Télécommunications de Tunis

Nom et prénom : rania labidi

Classe : BD_1
1) Déclarer la structure de donnée Etud qui permet de définir un type
d’enregistrement Etudiant contenant les champs suivants : nom (chaine de
caractère), prénom (chaine de caractère) et moyenne (réel) ?
Type
Etudiant : Enregistrement
nom : chaine[30]
prénom : chaine[30]
moyenne : réel
Fin Etudiant
2) Déclarer un type Tab_Etud : un tableau contenant au maximum 200
étudiants ?
Type
Tab_Etud: Tableau de 10 Etudiant
3) Déclarer un type liste simplement chainée L_etud dont les éléments sont
des étudiants ?
Type
L_etud: ^Etudiant
Etudiant : Enregistrement
nom : chaine[30]
prénom : chaine[30]
moyenne : réel
suiv : L_etud
Fin Etudiant
4) Ecrire une procédure Remplir_Etud qui permet d’initialiser un tableau T
avec des informations concernant N étudiants ? Calculer la complexité ?
Procédure Remplir_Etud (N : Entier ; var T : Tab_Etud)
Var
i : Entier
Début
Pour i de 1 à N faire
Ecrire ("Etudiant n°", i," :")
Ecrire ("Nom : ")
Lire (T[i].nom)
Ecrire ("Prénom : ")
Lire (T[i].prénom)
Ecrire ("Moyenne : ")
Lire (T[i].moyenne)
Pour Fin

Page1|6
 Fin
La complexité de cette procédure est de O(N), car elle effectue N itérations de la boucle
POUR et exécute un nombre constant d'opérations à chaque itération.
5) Ecrire la fonction Créer_liste qui permet de créer une liste chainée à partir
des informations concernant n étudiants contenues dans le tableau T et
renvoie la liste d’étudiants correspondante ? Calculer la complexité ?
{Fonction de création de la liste chaînée à partir du tableau des étudiants}
Fonction Créer_liste (T : Tab_Etud ; N : Entier) : L_etud
Var
tete, courant : L_etud;
i : Entier
Début
tete <- nil
courant <- nil
{Parcourir le tableau et créer un nœud (nouveau) pour chaque étudiant}
Pour i de 1 à N faire
Allouer (nouveau)
nouveau^.nom <- T[i].nom
nouveau ^.prénom <- T[i].prénom
nouveau ^.moyenne <- T[i].moyenne
nouveau ^.suiv <- nil
{Si la liste est vide, le nouveau nœud (nouvelEtud) devient le début de la liste}
Si (tete = nil) Alors
tete <- nouveau ;
courant <- tete;
Sinon
{Sinon, ajouter le nouveau nœud (nouveau) à la fin de la liste}
courant^.suiv <- nouveau ;
courant <- courant^.suiv;
FinSI
Fin Pour
Créer_liste <- tete
Fin
La complexité de cette fonction est de O(N), car elle effectue N itérations de la boucle
POUR et exécute un nombre constant d'opérations à chaque itération.

7) Ecrire une fonction rechercher1 (version itérative) qui vérifie si un étudiant

se trouve dans la liste (donnée par le pointeur L) et renvoie l’adresse de
l’élément correspondant, ou NIL si aucun ne lui correspond ? Calculer la
complexité ?
FONCTION rechercher1(L: L_etud; nom_cherché: Chaine; prenom_cherché:
Chaine): L_etud
Var
p : L_etud;
Début
p <- L

Page2|6
 trouve <- faux
Tant que (p <> nil) ET (trouve = faux) Faire
Si (p.nom = nom_cherché) ET (p.prenom = prenom_cherché) Alors
trouve <- VRAI
Sinon
p <- p^.suiv
Fin Si
Fin Tant que
Si trouve Alors
rechercher1 <- p
Sinon
rechercher1 <- nil
Fin Si
Fin
La complexité de cette fonction est de O(N), où N est le nombre d'étudiants dans la liste
chaînée, car dans le pire des cas, elle doit parcourir tous les nœuds de la liste chaînée.
8) Ecrire une fonction rechercher2 (version récursive) qui vérifie si un étudiant
se trouve dans la liste (donnée par le pointeur L) et renvoie l’adresse de
l’élément correspondant, ou NIL si aucun ne lui correspond ? Calculer la
complexité ?
Fonction rechercher2(L: L_etud; nom_cherché: Chaine; prenom_cherché: Chaine):
L_etud
Début
Si L = nil Alors
rechercher2 <- faux
Sinon
Si L^.nom = nom_cherché et L^.prénom = prenom_cherché Alors
rechercher2 <- vrai
Sinon
rechercher2 <- rechercher1(nom_cherché,prenom_cherché, L^.suiv)
Fin Si
Fin Si
Fin
La complexité de cette fonction est linéaire en fonction de la taille de la liste, car dans le
pire des cas elle doit parcourir toute la liste pour trouver l'étudiant recherché. La
complexité est donc O(n), où n est le nombre d'étudiants dans la liste.
9) Ecrire une procédure Eclater (L1 : ^ L_etud ; var L2 : ^ L_etud, var L3 : ^
L_etud) qui permet d’éclater une liste L1 d’étudiants en deux listes : L2
contenant les étudiants ayant une moyenne <10 et L3 contenant les
étudiants ayant une moyenne >=10 ? Calculer la complexité ?
{L2 contient les moyennes <10}
{L3 contient les moyennes >=10 }
Procédure Eclater(L1 : ^ L_etud ; var L2 : ^ L_etud, var L3 : ^ L_etud)
VAR
p1, p2, p3: L_etud;
Début

Page3|6
 p1 <- L1;
p2 <- NIL;
p3 <- NIL;
Tant que p1 ≠ NIL Faire
Si p1^.moyenne < 10 Alors
SI p2 = NIL Alors
p2 <- p1
L2 <- p2
Sinon
p2^.suiv <- p1;
p2 <- p1;
Fin Si
Sinon
Si p3 = NIL Alors
p3 <- p1;
L3 <- p3;
Sinon
p3^.suiv := p1;
p3 := p1;
Fin Si
Fin Si

p1 <- p1^.suiv;
Fin Tant que

Si p2 ≠ NIL Alors
p2^.suiv <- NIL;
fin si
Si p3 ≠ NIL Alors
p3^.suiv <- NIL;
fin si
Fin
La complexité de cette procédure est de O(N), où N est le nombre d'étudiants dans la liste
chaînée L1, car elle doit parcourir tous les nœuds de la liste chaînée une fois pour les
ajouter à la liste L2 ou L3.
10) Ecrire la procédure AfficheListe qui permet d’afficher le nom, le prénom et
la moyenne des étudiants admis (moyenne >=10) de la liste L ? Calculer la
complexité ?
Procédure AfficheListe (L : L_etud)
Var
p : L_etud
Début
p <-L
Tant que p ≠ nil Faire
Si p^.moyenne >= 10 Alors
Ecrire(p^.nom)

Page4|6
 Ecrire(p^.prénom)
Ecrire(p^.moyenne)
Fin Si
p<-p^.suiv
Fin Tant que
Fin
La complexité de cette procédure est de O(N), où N est le nombre d'étudiants dans la liste
chaînée L, car elle doit parcourir tous les nœuds de la liste chaînée une fois pour afficher
les informations des étudiants admis.
11) Ecrire l’algorithme principal qui permet de :
− remplir un tableau A par nb étudiants (nb est donné par l’utilisateur,
nb>=5 et nb <= 100), en utilisant Remplir_Etud.
− créer une liste chainée L à partir de ce tableau A, en utilisant
Créer_liste.
− éclater la liste L en deux listes : l’une contient les étudiants ayant
une moyenne <10 et l’autre contient les étudiants ayant une
moyenne >=10, en utilisant Eclater.
− Afficher la liste des étudiants admis (moyenne >=10), en utilisant
AfficheListe.
Algorithme DS2023
Type

Etudiant : Enregistrement
nom : chaine[30]
prénom : chaine[30]
moyenne : réel
Fin Etudiant
Tab_Etud: Tableau de 10 Etudiant

L_etud: ^Etudiant
Etudiant : Enregistrement
nom : chaine[30]
prénom : chaine[30]
moyenne : réel
suiv : L_etud
Fin Etudiant
Var
A : Tab_Etud
N : Entier
Maliste , liste1, liste2 : L_etud
{Procédures réalisées}
{Fonctions réalisées}
{Programme principal}
Début

Page5|6
 Répéter
Ecrire("nombre d'étudiants")
Lire(N)
Jusqu’à N ≥ 5 ET N ≤ 100
{Remplissage du tableau}
Procédure Remplir_Etud (N, A)
maliste = Créer_liste (A, N)
{Éclater la liste en liste1 et liste2}
Eclater(maliste, liste1,liste2)
{Afficher la liste2 qui contient les moyenne >=10}
AfficheListe (liste2)
Fin

Page6|6