Algorithmique et structures de données

TD N°3 : LES LISTES CHAINEES SIMPLES

Niveau : 1ère année IM Année universitaire : 2017/2018

Exercice N°1 :

Le but de cet exercice est d’écrire un algorithme qui permet de mémoriser dans une liste simplement
chaînée les informations relatives aux 15 joueurs d’une équipe de rugby et de traiter ses informations.
Un joueur est caractérisé par son nom, son prénom et son poids. Chaque joueur à un numéro de poste
(de 1 à 15) qui détermine son rôle dans l’équipe (le numéro 1 est pilier gauche, le numéro 2 est
talonneur, etc.).
1. Déclarer les structures de données adéquates permettant de représenter une liste de joueurs.
2. Ecrire une procédure créer_liste(…) qui permet de construire une liste de 15 joueurs
3. Ecrire une fonction plus_lourd(…) permettant de renvoyer l’adresse du joueur le plus lourd de
l’équipe.

Exercice N°2 :

Un processus se caractérise par son identificateur et son ordre de priorité (l’ordre de priorité
correspond à une valeur entière comprise entre 1 et 5).
On se propose de simuler le comportement d’un ordonnanceur de processus qui fonctionne de la
manière suivante :
 Tous les processus gérés par l’ordonnanceur sont stockés dans une liste unidirectionnelle
(simple chaînage).
 Les processus sont triés dans la liste selon l’ordre de priorité puis l’ordre d’arrivée. Par
exemple, un processus P1 qui a un niveau de priorité égal à 1 est plus prioritaire que le
processus P2 ayant le niveau de priorité 2 et ainsi de suite. Le processus P1 doit donc
apparaître dans la liste avant P2. De plus, si deux processus appartiennent à un même niveau
de priorité, celui qui est arrivé le premier doit apparaître avant dans la liste.
Çi-dessous un exemple d’une liste contenant 4 processus (Remarque : P5 est arrivé avant P2).

P5 1 P2 1 P1 3 P3 4 nil

1. Proposer une structure algorithmique « processus » permettant de représenter un processus.

 2. Définir le type « liste_proc » correspondant à la structure de données permettant de
représenter un ensemble de processus (à travers une liste chaînée simple).
3. Ecrire une procédure ajouter_processus(proc : processus, VAR L : ^liste_proc) qui ajoute un
processus à la liste à l’emplacement adéquat.
4. Ecrire une fonction lancer_processus(VAR L : ^liste_proc) : ^liste_proc qui permet de
débrancher le processus le plus prioritaire dans la liste L et de retourner son adresse.

Exercice N°3 :

Le codage des polynômes peut être réalisé au moyen d'une liste dynamique, il consiste à stocker dans
une liste simplement chaînée ordonnée des monômes.
Un monôme est constitué par un coefficient et un degré. Ainsi la liste suivante permet de coder le
polynôme 1+5x+2x3-6x5 est comme suit :

1 0 5 1 2 3 -6 5

Coefficient Degré Nil

La structure de la liste utilisée est la suivante :

Type
Monôme = enregistrement :
degre : entier
coef : réel
suiv : ^ Monôme
Fin
Polynôme=^Monôme

Développer les modules suivants :

1. La procédure affichePoly(P : Polynôme) qui permet d'afficher le polynôme P.

Exemple : L'affichage du polynôme de la figure fig.1 donne "1x^0+5x^1+2x^3-6x^5"

2. La fonction copiePolynôme(P : Polynôme) : Polynôme qui renvoie une copie du polynôme P.

3. La procédure ajoutMonôme(d : entier, c : réel, VAR P : Polynôme) qui permet d'insérer un
monôme de degré d et de coefficient c dans le polynôme P, tout en le gardant trié dans l'ordre
croissant des degrés.
4. La procédure multiScalaire(s : réel, VAR P : Polynôme) qui multiplie le polynôme P par un
scalaire s.
Exemple : la multiplication du polynôme de la fig.1 par le scalaire 3 donne le polynôme :
3+15x+6x3-18x5
5. La procédure multiMonôme(d : entier, c : réel, VAR P : polynôme) qui multiplie un
polynôme P par un monôme de degré d et de coefficient c.
Exemple : la multiplication du polynôme de la fig.1 par le monôme 3x2 donne le polynôme :
3x2+15x3+6 x5-18x7
6. La fonction sommePoly(P1 : Polynôme, P2 : Polynôme) : Polynôme qui renvoie dans un
nouveau polynôme le résultat de la somme de deux polynômes P1 et P2.
 Exemple : si P1= 1+5x+2x3-6x5 et P2 = 4+2x+3x2-5x3+2x4+6x5
P1+ P2 donne : 5+7x+3x2-3x3+2x4
7. La fonction évaluerPoly(P : Polynôme, x : réel) : réel qui retourne la valeur du polynôme
pour x.
Exercice N°4
AM-STRAM-GRAM est un jeu dans lequel n enfants forment une ronde et choisissent l'un d'entre eux
comme étant le premier. Puis ils commencent à partir de lui et décident que le kieme enfant doit quitter
la ronde, puis recommencent à compter, et le kieme suivant doit également sortir et ainsi de suite,
jusqu'au dernier enfant restant.
Par exemple, si on a 8 enfants notés e1, e2, ..., e8, pour k=3, les enfants sortiront dans l'ordre suivant :
e3, e6, el, e5, e2, e8, e4 et le dernier restant est e7 (qui est donc le gagnant).

Pour k=3, on compte 3 à partir

du premier enfant : c'est e3 qui e2
va sortir en premier lieu. Premier enfant de la
ronde
Premier enfant de la e1
ronde e2
e4
e3
e1
e8
e4 e5

e7
e8 e6
e5
Après avoir supprimé e3, on
e7 compte 3 à partir de e4, c'est
e6 donc e6 qui doit être supprimé.

e2

e1
e4

e8 Après avoir supprimé e6, on

e5 compte 3 à partir de e7, c'est e1 qui
sera supprimé… et ainsi de suite
jusqu'à ce qu'il nous reste un seul
e7 enfant dans la ronde

Premier enfant de la
ronde

On se propose de représenter la ronde des enfants par une liste circulaire simplement chaînée. Un
enfant est caractérisé uniquement par son nom et son sexe.
1. Définir les types enfant et ronde permettant de représenter respectivement un enfant et une
ronde d'enfants.
2. Ecrire la fonction compter_filles (L : ronde) : entier, qui renvoie le nombre de filles dans
ronde.
3. Développer la procédure ajouter_enfant(enf : enfant; var L : ronde) permettant d'ajouter
un enfant enf donné au début de la liste L.
4. Ecrire la procédure sortir_enfant(k : entier; var L : ronde) qui permet de supprimer le kéme
enfant de la liste à partir de l'adresse L. la fonction doit aussi placer le pointeur L sur la cellule
qui suit celle qui est supprimée.
5. En se basant sur la procédure précédente, implémenter la fonction retourner_gagnant(k :
entier; var L : ronde) : ronde, qui doit retourner l'adresse du dernier enfant restant dans la
ronde.
6. Ecrire un algorithme qui permet de :
. Construire une ronde de n enfants (n est donnée par l'utilisateur; n> 1).
. Afficher le nom du joueur gagnant si le pas k = 3.