Université des Sciences, des Techniques et des Technologies de

Bamako
FST 2020
TD N° 1 (INF1301) : Structures de données et Programmation

Exercice 1 : Recherche multidimensionnelle

a) Ecrire une fonction qui prend en paramètre un tableau d’entiers de deux dimensions (i.e.
un tableau dont les éléments sont des tableaux qui contiennent des entiers) et un entier x.
La fonction doit renvoyer Vrai si x est dans le tableau, et Faux sinon.
b) Quelle est la complexité de votre algorithme en fonction des dimensions du tableau fourni
en paramètre ?
c) Modifier l’algorithme obtenu pour qu’il compte le nombre d’occurrences de l’élément x
dans le tableau. Est-ce que la complexité de l’algorithme change ?
d) Ecrire les implémentations en C des deux versions de votre algorithme.

Exercice 2 : Structure Point

a) Définir une structure Point caractérisée par une abscisse réelle et une ordonnée réelle.
b) Ecrire l’implémentation des fonctions suivantes :
- Point CreerPoint () : qui retourne un point de coordonnées (0,0).
- Réel distance (Point p, Point q) ;
c) Proposer une implémentation en C.

Exercice 3 : Structure Nombre Complexe

a) Définir une structure NombreComplexe caractérisée par une partie réelle et une partie
imaginaire.
b) Ecrire l’implémentation des fonctions suivantes :
- Point CreerNombreComplexe () : qui retourne un nombre complexe de parties réelle
et imaginaire nulles.
- Réel module(NombreComplexe c) qui calcule le module d’un nombre complexe
donné ;
- NombreComplexe addition (NombreComplexe c1, NombreComplexe c2) qui calcule
la somme de deux nombres complexes.
- NombreComplexe produit (NombreComplexe c1, NombreComplexe c2) qui calcule le
produit de deux nombres complexes.
c) Proposer une implémentation en C.

1
Exercice 4 : Représentation d’une matrice en C
L’objectif de cet exercice est de créer une bibliothèque pour manipuler les matrices (tableaux à
deux dimensions) de réels
1) Proposer un type C pour représenter les matrices de réels en utilisant les structures et les
pointeurs. Les matrices seront de dimension m × n où m désigne le nombre de lignes et n
le nombre de colonnes.
2) Ecrire une fonction creerMatrice () permettant de créer une matrice, dont les coefficients
ne sont pas initialisés.
3) Ecrire une fonction libérerMatrice (Matrice m) permettant de libérer la mémoire allouée à
une matrice.
4) Ecrire une fonction de copieMatrice (Matrice a, Matrice b) permettant de copier une
matrice.
5) Soit c une constante réelle, on souhaite disposer de constructeurs produisant des matrices
courantes :
- La matrice pleine, 𝑎𝑖𝑗 = 𝑐 pour tous 𝑖, 𝑗,
- La matrice diagonale, 𝑎𝑖𝑗 = 𝑐 pour tout 𝑖 et 𝑎𝑖𝑗 = 0 pour 𝑖 ≠ 𝑗,
- Les matrices triangulaires supérieures, telles que 𝑎𝑖𝑗 = 𝑐 si 𝑖 ≤ 𝑗, et 𝑎𝑖𝑗 = 0 sinon,
- Les matrices triangulaires inférieures, telles que 𝑎𝑖𝑗 = 𝑐 si 𝑖 ≥ 𝑗, et 𝑎𝑖𝑗 = 0 sinon.
Ecrire une fonction pour chaque type de matrice, qui initialisera une matrice déjà existante.
6) Ecrire une fonction afficherMatrice (Matrice m) permettant d’afficher les éléments d’une
matrice.
7) Implémenter la fonction void transposerMatrice (Matrice A, Matrice B) qui définit B
comme la transposée de A ( 𝑖. 𝑒. 𝑏𝑖𝑗 = 𝑎𝑗𝑖 pour tous 𝑖, 𝑗). Que se passe-t-il lors d’un appel
du type transposerMatrice (A, A)?
8) Implémenter la fonction void additionMatrice (Matrice A, Matrice B, Matrice C) qui
réalise l’addition de deux matrices (𝑐𝑖𝑗 = 𝑎𝑖𝑗 + 𝑏𝑖𝑗 pour tous 𝑖, 𝑗). Que se passe-t-il lors
d’un appel du type additionMatrice (A, B, A)?
9) Implémenter la fonction void produitMatrice (Matrice A, Matrice B, Matrice C) qui réalise
le produit de deux matrices (𝑐𝑖𝑗 = ∑𝑛𝑘=1 𝑎𝑖𝑘 𝑏𝑘𝑗 pour tous 𝑖, 𝑗). Que se passe-t-il lors d’un
appel du type produitMatrice (A, B, C) ?
10) On définit 𝑃𝑘𝑙 comme la matrice égale à la matrice identité sauf pour 4 coefficients : 𝑝𝑘𝑘 =
𝑝𝑙𝑙 = 0 et 𝑝𝑘𝑙 = 𝑝𝑙𝑘 = 1 . La matrice 𝑃𝑘𝑙 est appelée matrice de permutation ;
expliquez pourquoi en calculant 𝐴𝑃𝑘𝑙 et 𝑃𝑘𝑙 𝐴, où 𝐴 est une matrice quelconque.

2
Exercice 5 : Damier
Le jeu de dames se joue sur un damier carré divisé en 100 cases égales, alternativement claires et
foncées.
• Le jeu se joue sur les cases foncées du damier. Il y a donc 50 cases actives. La plus longue
diagonale, joignant deux coins du damier et comprenant 10 cases foncées, se dénomme la
grande diagonale.
• Le damier doit être placé de sorte que la première case de gauche, pour chaque joueur, soit
une case foncée.
• Le jeu de dames international se joue avec 20 pions blancs (clairs) et 20 pions noirs
(foncés). Avant de débuter une partie, les 20 pions noirs et les 20 pions blancs sont disposés
sur les 4 premières rangées de chaque joueur.
Notre objectif dans cet exercice est de proposer une structure de données permettant se stocker le
damier en mémoire, nous n’allons pas nous intéresser aux algorithmes des règles de jeu et des
stratégies. Pour plus d’informations veuillez consulter :
http://www.ffjd.fr/Web/index.php?page=reglesdujeu.

Considérez le damier d’un jeu de dame présenter sur la figure ci-dessous :

Figure 1. Damier

1) Définissez les types pour stocker le damier en mémoire.

2) Ecrire un algorithme qui initialise le damier en posant les pions noirs et blanc sur le
damier conformément à la Figure 1.
3) Ecrire un algorithme qui détermine le joueur qui est en train de gagner la partie, c’est-à-
dire de quelle couleur il y a plus de pions sur le damier.

3
Exercice 6 : Définition d’une liste
Une liste est une séquence de zéro ou plusieurs éléments d’un type donnée.
On notera 𝐿𝑖𝑠𝑡𝑒 < 𝑇 > le type de liste dont les éléments sont de type 𝑇 (par exemple une liste
d’entier est de type 𝐿𝑖𝑠𝑡𝑒 < 𝑒𝑛𝑡𝑖𝑒𝑟 >).
Les opérations possibles sur une liste sont les suivantes :
• 𝑃𝑜𝑠𝑖𝑡𝑖𝑜𝑛 𝑑𝑒𝑟𝑛𝑖𝑒𝑟(𝐿𝑖𝑠𝑡𝑒 < 𝑇 >): Retourne la position du dernier élément de la liste.
• 𝐿𝑖𝑠𝑡𝑒 < 𝑇 > 𝑐𝑟é𝑒𝑟𝐿𝑖𝑠𝑡𝑒(): crée une liste constituée d’une suite vide.
• 𝐼𝑛𝑠𝑒𝑟𝑒𝑟𝐸𝑛𝑇𝑒𝑡𝑒(𝐿𝑖𝑠𝑡𝑒 < 𝑇 > 𝐿, 𝑇 𝑥): insère l’élément en tête de liste.
• 𝑖𝑛𝑠𝑒𝑟𝑒𝑟𝐴𝑝𝑟𝑒𝑠(𝐿𝑖𝑠𝑡𝑒 < 𝑇 > 𝐿, 𝑃𝑜𝑠𝑖𝑡𝑖𝑜𝑛 𝑝, 𝑇 𝑥): insère l’élément 𝑥 après la position 𝑝.
• 𝑠𝑢𝑝𝑝𝑟𝑖𝑚𝑒𝑟 (𝐿𝑖𝑠𝑡𝑒 < 𝑇 > 𝐿, 𝑃𝑜𝑠𝑖𝑡𝑖𝑜𝑛 𝑝) : Supprime l’élément à la position 𝑝 dans la
liste L.
• 𝑒𝑠𝑡𝑉𝑖𝑑𝑒(𝐿𝑖𝑠𝑡𝑒 < 𝑇 > 𝐿): retourne 𝑣𝑟𝑎𝑖 si la liste est vide
• 𝐶𝑜𝑛𝑡𝑒𝑛𝑢(𝐿𝑖𝑠𝑡𝑒 < 𝑇 > 𝐿, 𝑃𝑜𝑠𝑖𝑡𝑖𝑜𝑛 𝑝) : Retourne l’élément à la position 𝑝 dans la liste.
Le résultat est indéfini si 𝑝 = 𝑓𝑖𝑛(𝐿) ou si la position 𝑝 n’existe pas.
• 𝑃𝑟𝑒𝑚𝑖𝑒𝑟(𝐿𝑖𝑠𝑡𝑒 < 𝑇 > 𝐿): retourne la première position dans la liste 𝐿.
 𝑇 𝑇𝑒𝑡𝑒(𝐿𝑖𝑠𝑡𝑒 < 𝑇 > 𝐿): retourne l’élément qui est à la première position de la liste 𝐿.
Indéfini si 𝐿 est vide.
 𝑇 𝑄𝑢𝑒𝑢𝑒(𝐿𝑖𝑠𝑡𝑒 < 𝑇 > 𝐿) : Retourne l’élément qui est à la dernière position dans la liste
𝐿. Indéfini si 𝐿 est vide.
 𝐸𝑛𝑡𝑖𝑒𝑟 𝐿𝑜𝑐𝑎𝑙𝑖𝑠𝑒𝑟 (𝐿𝑖𝑠𝑡𝑒 < 𝑇 > 𝐿, 𝑇 𝑥) : retourne la position de l’élément 𝑥 dans la
liste. Si 𝑥 apparait plusieurs fois, c’est la position de la première occurrence de 𝑥. Si
𝑥 n’existe dans 𝐿 alors 𝑓𝑖𝑛() est retournée.
 𝑉𝑖𝑑𝑒𝑟(𝐿𝑖𝑠𝑡𝑒 < 𝑇 >): vide la liste
 𝐴𝑓𝑓𝑖𝑐ℎ𝑒𝑟(𝐿𝑖𝑠𝑡𝑒 < 𝑇 > 𝐿): affiche les éléments de la liste 𝐿 dans l’ordre d’apparition
dans L

1. Ecrire les algorithmes des opérations définies ci-dessus.

2. Ecrire une d’une fonction qui prend une liste en argument et élimine les éléments
dupliqués de la liste.

Exercice 7 : Définition d’une Pile

Une pile (en anglais stack) est une suite d'éléments de type T. La notion de pile est fondée sur le
principe « dernier arrivé, premier sorti » (en anglais LIFO pour last in, first out). Une Pile est une
liste particulière.
Les opérations de base possibles sur une pile sont les suivantes :
• 𝐵𝑜𝑜𝑙é𝑒𝑛 𝑝𝑖𝑙𝑒𝑉𝑖𝑑𝑒( 𝑃𝑖𝑙𝑒 < 𝑇 > 𝑃 ) : Retourne 𝑣𝑟𝑎𝑖 si la suite 𝑃 est vide ; 𝑓𝑎𝑢𝑥 sinon.
• 𝑇 𝑠𝑜𝑚𝑚𝑒𝑡(𝑃𝑖𝑙𝑒 < 𝑇 > 𝑃 ) : Retourne l’élément x de type T qui est au sommet de la pile
sans le supprimer ; P doit être non vide
• 𝑒𝑚𝑝𝑖𝑙𝑒𝑟 (𝑃𝑖𝑙𝑒 < 𝑇 > 𝑃, 𝑇 𝑥 ): ajoute l’élément x au sommet de la pile.
4
 • 𝑑𝑒𝑝𝑖𝑙𝑒𝑟 (𝑃𝑖𝑙𝑒 < 𝑇 > 𝑃 ): retourne et supprimer l’élément qui est au sommet de la pile;
P doit être non vide
• 𝑃𝑖𝑙𝑒 < 𝑇 > 𝑐𝑟𝑒𝑒𝑟𝑃𝑖𝑙𝑒 () : Retourne une suite vide

1. Ecrire les algorithmes des opérations définies ci-dessus.

2. Ecrire une fonction qui permet d’afficher tous les éléments d’une Pile.

Exercice 8 : Définition d’une File

Une file dite aussi file d'attente, est une structure de données basée sur le principe du premier
entré, premier sorti (en anglais FIFO (« first in, first out »). Une File est une liste particulière.
Les différentes opérations possibles sur les files sont les suivantes :
• 𝑏𝑜𝑜𝑙é𝑒𝑛 𝑓𝑖𝑙𝑒𝑉𝑖𝑑𝑒( 𝐹𝑖𝑙𝑒(𝑇) 𝐹) : retourne vrai si f est la suite vide ; faux sinon.
• 𝑇 𝑡𝑒𝑡𝑒( 𝑓𝑖𝑙𝑒 < 𝑇 > 𝐹) : retourne l'élément x de type T tel que F = xF’ ; F doit être non
vide
• 𝑒𝑛𝑓𝑖𝑙𝑒𝑟 ( 𝐹𝑖𝑙𝑒 < 𝑇 > 𝑇, 𝑇 𝑥 ) 𝐹 ← 𝐹𝑥
• 𝑑𝑒𝑓𝑖𝑙𝑒𝑟 ( 𝐹𝑖𝑙𝑒 < 𝑇 > 𝐹 ) F←F’, F’ tel que F=xF’ ; F doit être non vide
• 𝐹𝑖𝑙𝑒 < 𝑇 > 𝑐𝑟𝑒𝑒𝑟𝐹𝑖𝑙𝑒 (): retourne la suite vide
1. Ecrire les algorithmes des opérations définies ci-dessus.
2. Ecrire une fonction qui permet d’afficher tous les éléments d’une File.

Exercice 9 : Implémentation d’une liste sous forme de tableau

L’objectif de cet exercice est de proposer une implémentation de liste d’entier sous forme de
tableau.
1. Avant de proposer les algorithmes des opérations de base sur les listes, il faut définir la
structure Liste qui possède comme attributs un tableau d’entier contenant les éléments de
la liste et un entier dernier qui désigne la position du dernier élément i.e. celui qui est en
queue. Comme les tableaux ne supportent pas l’ajout arbitraire d’éléments, vous devez
choisir une taille maximale pour votre tableau.
2. Proposer un algorithme pour chacune des opérations suivantes :
o Pile creerListe();crée une liste constituée d’une suite vide.
o Booléen estVile(Liste l);
o vide afficherListe(Liste l); affiche les éléments de la liste 𝐿 dans l’ordre
d’apparition dans L.
o entier longueurPile(Pile p);
o Pile viderListe(Pile p);
o 𝑃𝑜𝑠𝑖𝑡𝑖𝑜𝑛 𝑓𝑖𝑛(𝐿𝑖𝑠𝑡𝑒 𝑙): Retourne la position qui suit le dernier élément de la liste.
o 𝐼𝑛𝑠𝑒𝑟𝑒𝑟𝐸𝑛𝑇𝑒𝑡𝑒(𝐿𝑖𝑠𝑡𝑒 𝐿, 𝑒𝑛𝑡𝑖𝑒𝑟 𝑥): insère l’élément en tête de liste.
o 𝑖𝑛𝑠𝑒𝑟𝑒𝑟𝐴𝑝𝑟𝑒𝑠(𝐿𝑖𝑠𝑡𝑒 𝐿, 𝑒𝑛𝑡𝑖𝑒𝑟 𝑝, 𝑒𝑛𝑡𝑖𝑒𝑟 𝑥): insère l’élément 𝑥 après la position
𝑝.

5
 o 𝑠𝑢𝑝𝑝𝑟𝑖𝑚𝑒𝑟 (𝐿𝑖𝑠𝑡𝑒 𝐿, 𝑒𝑛𝑡𝑖𝑒𝑟 𝑝) : Supprime l’élément à la position 𝑝 dans la liste
L.
o 𝐶𝑜𝑛𝑡𝑒𝑛𝑢(𝐿𝑖𝑠𝑡𝑒 𝐿, 𝑒𝑛𝑡𝑖𝑒𝑟 𝑝) : Retourne l’élément à la position 𝑝 dans la liste. Le
résultat est indéfini si 𝑝 = 𝑓𝑖𝑛(𝐿) ou si la position 𝑝 n’existe pas.
o 𝑃𝑟𝑒𝑚𝑖𝑒𝑟(𝐿𝑖𝑠𝑡𝑒 𝐿): retourne la première position dans la liste 𝐿.
o 𝑒𝑛𝑡𝑖𝑒𝑟 𝑇𝑒𝑡𝑒(𝐿𝑖𝑠𝑡𝑒 𝐿): retourne l’élément qui est à la première position de la
liste 𝐿. Indéfini si 𝐿 est vide.
o 𝑒𝑛𝑡𝑖𝑒𝑟 𝑄𝑢𝑒𝑢𝑒(𝐿𝑖𝑠𝑡𝑒 𝐿) : Retourne l’élément qui est à la dernière position dans la
liste 𝐿. Indéfini si 𝐿 est vide.
o 𝐸𝑛𝑡𝑖𝑒𝑟 𝐿𝑜𝑐𝑎𝑙𝑖𝑠𝑒𝑟 (𝐿𝑖𝑠𝑡𝑒 𝐿, 𝑒𝑛𝑡𝑖𝑒𝑟 𝑥) : retourne la position de l’élément 𝑥 dans la
liste. Si 𝑥 apparait plusieurs fois, c’est la position de la première occurrence de 𝑥.
Si 𝑥 n’existe dans 𝐿 alors 𝑓𝑖𝑛() est retournée.
o 𝑉𝑖𝑑𝑒𝑟(𝐿𝑖𝑠𝑡𝑒 < 𝑇 >): vide la liste.
3. Proposer une implémentation de la notion de pile et de ses opérations en C.

6
Exercice 10 : Implémentation sous forme de tableau d’une pile d’entiers
L’objectif de cet exercice est de proposer une implémentation de pile d’entier sous forme de
tableau.
L’implémentation en utilisant un tableau fonctionne comme présentée sur la figure ci-dessous :

Figure 2. Une Pile P

Les éléments de la pile apparaissent uniquement aux positions en gris clair. (a) La pile P contient
4 éléments. L’élément qui se trouve au sommet est 9. (b) L’état de la pile P après les appels empiler
(P, 17) et empiler (P, 3). (c) L’état de la pile P après que l’appel dépiler(P) a retourné 3, qui est
l’élément le plus récemment empilé. Bien que l’élément 3 apparaisse encore dans le tableau, il
n’est plus dans la pile ; le sommet est occupé par l’élément 17.
4. Avant de proposer les algorithmes des opérations de base sur la Pile, il faut définir la
structure Pile qui possède comme attributs un tableau d’entier contenant les éléments de la
pile et un entier sommet qui désigne la position du dernier élément. Comme les tableaux
ne supportent pas l’ajout arbitraire d’éléments, vous devez choisir une taille maximale pour
votre tableau.
5. Proposer un algorithme pour chacune des opérations suivantes :
o Pile creerPile();
o Booléen estVile(Pile p);
o vide imprimerPile(Pile p);
o vide empiler(Pile p, int x);
o entier depiler(Pile p);
o entier sommet(Pile p);
o entier longueurPile(Pile p);
o Pile viderPile(Pile p);

7
 6. Proposer une implémentation de la notion de pile et de ses opérations en C.

Exercice 11 : Implémentation sous forme de tableau d’une File d’entiers

L’objectif de cet exercice est de proposer une implémentation de File d’entier en utilisant un
tableau.
1. Définir une structure File qui possède comme attributs un tableau (elements) qui devra
contenir les éléments de la file, un entier tête et un entier queue. L’entier tête repère
l’élément qui est en tête et queue indexe le prochain emplacement pouvant conserver un
nouvel élément. Lorsqu’un élément est enfilé, il prend place à la queue de la file. L’élément
défilé est toujours le premier en tête de la file.
2. Proposer un algorithme pour chacune des opérations suivantes :
o File creerFile(void);
o Booléen estVile(File f);
o vide imprimerFile(File f);
o vide enfiler(File f, int x);
o entier defiler(File f);
o entier premier(File f);
o entier dernier(File f);
o entier longueurFile(File f);
o File viderFile(File f);
3. Proposer une implémentation de la notion de File et de ses opérations en C.
La figure ci-dessous montre comment fonctionne l’implémentation sous forme de tableau.

Figure 3. Une File F Sous Forme de Tableau

Les éléments de la file apparaissent uniquement aux positions en gris clair. (a) La file contient 5
éléments, aux emplacements F [6 . . 10]. (b) La configuration de la file après les appels enfiler (F,
17), enfiler (F, 3) et enfiler (F, 5). (c) La configuration de la file après l’appel défiler(F) qui retourne
la valeur 15 précédemment en tête de file. La nouvelle tête à la valeur 6.

8
Exercice 12 : Représentation d’une liste en C avec les pointeurs
1) Proposer un type C pour représenter les listes d’entiers.
2) Proposer une implémentation pour chacune des opérations données dans l’exercice sur la
définition d’une liste.
3) Ecrire un constructeur Liste cons (int h, Liste l) qui ajoute un élément en tête de liste ;
4) Ecrire une fonction libererListe (Liste l) permettant de libérer la mémoire allouée à une
liste.
5) Ecrire une fonction de copie de liste Liste copieLiset (Liste l).
6) Ecrire un algorithme qui permet de fusionner deux listes quelconques et retourne la liste
finale qui met les éléments de la deuxième liste à la suite des éléments de la première liste.
7) Ecrire un algorithme qui permet de fusionner deux listes triées dans l’ordre croissant et
retourne la liste finale.
8) Ecrire un algorithme qui permet d’éliminer tous les doublons dans une liste chaînée.
9) Implémenter les fonctions suivantes :
a. La fonction int longueur(Liste l) qui calcule la longueur d’une liste,
b. La fonction la fonction int occurrence (Liste l, entier x) qui calcule le nombre
d’occurrences d’un élément dans une liste. Proposer une autre version de la fonction
localiser en utilisant occurrence,
c. La fonction égale qui teste l’égalité de deux listes,
d. La fonction get qui retourne le ième élément d’une liste.

Exercice 13 : Représentation d’une Pile en C avec les pointeurs

1) Proposer un type C pour représenter les Piles d’entiers.
2) Proposer une implémentation pour chacune des opérations données dans l’exercice sur la
définition d’une Pile.
3) Ecrire une fonction libererPile() permettant de libérer la mémoire allouée à une Pile.
4) Ecrire une fonction de copie de Pile Pile copiePilet(Pile p).

Exercice 14 : Représentation d’une File en C avec les pointeurs

1) Proposer un type C pour représenter les Files d’entiers.
2) Proposer une implémentation pour chacune des opérations données dans l’exercice sur la
définition d’une File.
3) Ecrire un constructeur File creerFile(int h, File f ) qui ajoute un élément en tête de File;
4) Ecrire une fonction libererFile() permettant de libérer la mémoire allouée à une File.
5) Ecrire une fonction de copie de liste File copieFilet(File f).