Structure de Données Avancées

Support de cours de Structure de Données Avancées BTS Option GL Niv 2
La connaissance ne signifie pas

seulement savoir que 1+1=2.
Elle est une combinaison de trois

éléments :
1) Le savoir savant : Je sais que

1+1=2 (Théorie)
2) Le savoir-faire : je sais
calculer 1+1=2 (Pratique)
3) Le savoir être : Je sais

trouver que 1+1=2 (Ethique)
STRUCTURE DE DONNEES AVANCEES I
Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web: www.sergedoumi.net
Page 1
Fiche Matière
PRE REQUIS
Notions de base en Algorithme de base
OBJECTIF GENERAL
A la fin de ce cours l’étudiant sera capable de comprendre et expliquer les notions relatives aux
structure de données avancées I
OBJECTIFS SPECIFIQUES
A la fin de ce module l’étudiant sera capable de :

Maitriser les procédures et les fonctions
Comprendre les techniques de tris
Maitriser les techniques de recherche
Etre capable d’expliquer la récursivité
POPULATION
Profil : Brevet des Techniciens Supérieur
Option : GL
Niveau : II
EVALUATION
Contrôle continu
Evaluation semestrielle
MOYENS PEDAGOGIQUES
Support de cours
Travaux Dirigés

Page 2
Tables des Matières
Fiche Matière.............................................................................................................................. 2
Chapitre 1 PROCEDURES ET FONCTIONS .......................................................................... 5
I.) De quoi s'agit-il ? ................................................................................................................ 5
II.) Les fonctions ................................................................................................................... 7
Passage d'arguments ................................................................................................................... 7
III.) Sous-Procédures .............................................................................................................. 9
IV.) Travaux dirigés .............................................................................................................. 12
Chapitre 2 TECHNIQUES DE TRIS ................................................................................... 15
I.) Les tris a bulle ................................................................................................................... 15
A) Spécification abstraite ......................................................................................................... 15
B) Spécification concrète ......................................................................................................... 15
Algorithme : ............................................................................................................................. 16
II.) Tris par sélection ........................................................................................................... 17
III.) Travaux dirigés .............................................................................................................. 20
Chapitre 3 TECHNIQUES DE RECHERCHE DANS UN VECTEUR ................................ 21
I.) Recherche séquentielle linéaire ......................................................................................... 21
II.) Recherche séquentielle avec sentinelle ......................................................................... 22
III.) Recherche dichotomique ............................................................................................... 22
Chapitre 4 NOTION DE COMPLEXITE DES ALGORITHMES INFORMATIQUES ..... 25
Introduction .............................................................................................................................. 25
I.) Définition des notions de complexité en espace et temps d’exécution ............................ 25
II.) Détermination de la complexité .................................................................................... 25
a.) Cas N° 1 : Algorithme qui permute deux nombres. ...................................................... 25
b.) Cas N°2 : Algorithme qui calcule le factorielle d’un nombre ...................................... 26
III.) Types de complexité...................................................................................................... 26

Page 3
Exercice 1 ................................................................................................................................. 27
Exercice 2 ................................................................................................................................. 27
Chapitre 5 LA RECURCIVITE ......................................................................................... 28
I.) Introduction ....................................................................................................................... 28
II.) Fonction définies récursivement ................................................................................... 28
III.) Quelques exemples ........................................................................................................ 28
IV.) Types de récursivité ...................................................................................................... 29
V.) Travaux dirigés .............................................................................................................. 29

Page 4
Chapitre 1 PROCEDURES ET FONCTIONS
Objectif général : Bien comprendre les procédures et les fonctions
Objectifs spécifiques
Etre capable de:
Expliquer l’intérêt des procédures et fonctions

Connaitre la signature des procédures et fonctions
Connaitre la différence entre une procédure et une function
Connaitre les notions de paramètre global, local, formel et effectif
Développer des procédures et les fonctions
Exercice : 1, 2, 3, 4, 5, 6, 7, 8, 9 et 10
I.) De quoi s'agit-il ?

Une application, surtout si elle est longue, a toutes les chances de devoir procéder aux
mêmes traitements, ou à des traitements similaires, à plusieurs endroits de son déroulement.
Par exemple, la saisie d’une réponse par oui ou par non (et le contrôle qu’elle implique),
peuvent être répétés dix fois à des moments différents de la même application.
La manière la plus évidente, mais aussi la moins habile, de programmer ce genre de

choses, c'est bien entendu de répéter le code correspondant autant de fois que nécessaire.
Quand il faut que la machine interroge l'utilisateur, on recopie presque mot à mot les lignes de
codes voulues. Mais en procédant de cette manière, la pire qui soit, on se prépare des
lendemains qui déchantent.
D'abord, parce que si la structure d'un programme écrit de cette manière peut paraître
simple, elle est en réalité inutilement lourdingue. Elle contient des répétitions, et pour peu que
le programme soit joufflu, il peut devenir parfaitement illisible. Or, c'est un critère essentiel
pour un programme informatique, qu'il soit facilement modifiable donc lisible, y compris - et
surtout - par ceux qui ne l'ont pas écrit ! Dès que l'on programme non pour soi-même, mais
dans le cadre d'une organisation (entreprise ou autre), cette nécessité se fait sentir de manière
aiguë.
En plus, à un autre niveau, une telle structure pose des problèmes considérables de
maintenance : car en cas de modification du code, il va falloir traquer toutes les apparitions de
ce code pour faire convenablement la modification ! Et si l'on en oublie une, patatras, on a
laissé un bug.

Page 5
Il faut donc opter pour une autre stratégie, qui consiste à séparer ce traitement du corps
du programme et à appeler ces instructions (qui ne figurent donc plus qu’en un seul
exemplaire) à chaque fois qu’on en a besoin. Ainsi, la lisibilité est assurée ; le programme
devient modulaire, et il suffit de faire une seule modification au bon endroit, pour que cette
modification prenne effet dans la totalité de l’application.
Le corps du programme s’appelle alors la procédure principale, et ces groupes

d’instructions auxquels on a recours s’appellent des fonctions et des sous-procédures (nous
verrons un peu plus loin la différence entre ces deux termes). Reprenons un exemple de
question à laquelle l’utilisateur doit répondre par oui ou par non.
Mauvaise Structure :
Ecrire ("Etes-vous marié ?");
Rep1 ← "";
TantQue (Rep1 <> "Oui") et (Rep1 <> "Non")
Ecrire ("Tapez Oui ou Non");
Lire (Rep1)
FinTantQue
Ecrire ("Avez-vous des enfants ?");
Rep2 ← "";
TantQue (Rep2 <> "Oui") et (Rep2 <> "Non")
Lire (Rep2)
FinTantQue
On le voit bien, il y a là une répétition quasi identique du traitement à accomplir. A

chaque fois, on demande une réponse par Oui ou Non, avec contrôle de saisie. La seule chose
qui change, c'est le nom de la variable dans laquelle on range la réponse. Alors, il doit bien y
avoir un truc.
La solution consiste à isoler les instructions demandant une réponse par Oui ou Non,
et à appeler ces instructions à chaque fois que nécessaire. Ainsi, on évite les répétitions
inutiles, et on a découpé notre problème en petits morceaux autonomes.
Nous allons donc créer une fonction dont le rôle sera de renvoyer la réponse (oui ou
non) de l'utilisateur. Ce mot de "fonction", en l'occurrence, ne doit pas nous surprendre : nous
avons étudié précédemment des fonctions fournies avec le langage, et nous avons vu que le
but d'une fonction était de renvoyer une valeur. C’est exactement la même chose ici, sauf que
c'est nous qui allons créer notre propre fonction, que nous appellerons RepOuiNon :

Page 6
II.) Les fonctions

Fonction RepOuiNon() :char;
Truc ← "";
TantQue (Truc <> "Oui") et (Truc <> "Non")
Lire (Truc);
FinTantQue
Renvoyer Truc;
Fin
On remarque au passage l’apparition d’un nouveau mot-clé : Renvoyer, qui indique

quelle valeur doit prendre la fonction lorsqu'elle est utilisée par le programme. Cette valeur
renvoyée par la fonction (ici, la valeur de la variable Truc) est en quelque sorte contenue dans
le nom de la fonction lui-même, exactement comme c’était le cas dans les fonctions
prédéfinies.
Une fonction s'écrit toujours en-dehors de la procédure principale. Selon les langages,
cela peut prendre différentes formes. Mais ce qu'il faut comprendre, c'est que ces quelques
lignes de codes sont en quelque sorte des satellites, qui existent en dehors du traitement lui-
même. Simplement, elles sont à sa disposition, et il pourra y faire appel chaque fois que
nécessaire. Si l'on reprend notre exemple, une fois notre fonction RepOuiNon écrite, le
programme principal comprendra les lignes :
Ecrire ("Etes-vous marié ?");

Rep1 ← RepOuiNon();
Ecrire ("Avez-vous des enfants ?");
Rep2 ← RepOuiNon();
Et le tour est joué ! On a ainsi évité les répétitions inutiles, et si d'aventure, il y avait
un bug dans notre contrôle de saisie, il suffirait de faire une seule correction dans la fonction
RepOuiNon pour que ce bug soit éliminé de toute l'application. C'est-y pas beau, la vie ?
Toutefois, les plus sagaces d'entre vous auront remarqué, tant dans le titre de la
fonction, que dans chacun des appels, la présence de parenthèses. Celles-ci, dès qu'on crée on
qu'on appelle une fonction, sont obligatoires. Et si vous avez bien compris tout ce qui précède,
vous devez avoir une petite idée de ce qu'on va pouvoir mettre dedans...
Passage d'arguments
Reprenons l’exemple qui précède et analysons-le. Nous écrivons un message à l'écran,
puis appelons la fonction RepOuiNon pour poser une question ; puis, un peu plus loin, on

Page 7
écrit un autre message à l'écran, et on appelle de nouveau la fonction pour poser la même
question, etc. C’est une démarche acceptable, mais qui peut encore être améliorée : puisque
avant chaque question, on doit écrire un message, autant que cette écriture du message figure
directement dans la fonction appelée. Cela implique deux choses :
a) lorsqu’on appelle la fonction, on doit lui préciser quel message elle doit
afficher avant de lire la réponse
b) la fonction doit être « prévenue » qu’elle recevra un message, et être capable
de le récupérer pour l’afficher.
En langage algorithmique, on dira que le message devient un argument de la

fonction. La fonction sera dorénavant déclarée comme suit :
Fonction RepOuiNon (Msg : char) :char

Ecrire (Msg);
Truc ← "";
TantQue (Truc <> "Oui") et (Truc <> "Non")
Lire Truc;
FinTantQue
Renvoyer Truc;
Fin Fonction
Il y a donc maintenant entre les parenthèses une variable, Msg, dont on précise le type,
et qui signale à la fonction qu’un argument doit lui être envoyé à chaque appel. Quant à ces
appels, justement, ils se simplifieront encore dans la procédure principale, pour devenir :
Rep1 ← RepOuiNon ("Etes-vous marié ?");
Rep2 ← RepOuiNon ("Avez-vous des enfants ?");
Une remarque importante : là, on n'a passé qu’un seul argument en entrée. Mais bien
entendu, on peut en passer autant qu’on veut, et créer des fonctions avec deux, trois, quatre,
etc. arguments ; Simplement, il faut éviter beaucoup d’arguments, et il suffit de passer ce dont
on en a besoin.
Dans le cas que l'on vient de voir, le passage d'un argument à la fonction était élégant,
mais pas indispensable. La preuve, cela marchait déjà très bien lors de la première version.
Nous allons voir maintenant une situation où il faut absolument passer deux arguments à une
fonction si l'on veut qu'elle puisse remplir sa tâche.

Page 8
Imaginons qu'à plusieurs reprises au cours du programme, on ait à calculer la moyenne

des éléments de différents tableaux. Plutôt que répéter le code à chaque fois, on va donc créer
une fonction Moy, chargée spécialement de calculer cette moyenne. Voyons voir un peu de
quoi cette fonction a besoin :
• Comment calculer la moyenne de ses éléments ?

• mais il faut également le nombre d'éléments du tableau, ou, au choix, l'indice
maximal du tableau. Enfin, quelque chose qui permette à la fonction de savoir
combien de tours de boucle elle devra faire.
Voilà donc une situation où la fonction a absolument besoin de deux arguments.
Fonction Moy (T() : entier, n en Entier) :entier

Som ← 0;
Pour i ← 0 à n-1
Som ← Som + T(i);
m ← som / n;
Renvoyer m;
Fin Fonction
Quant aux différents appels dans la procédure principale, si j'ai un tableau Riri de 43
éléments, un tableau Fifi de 5 éléments et un tableau Loulou de k éléments, et que je range
respectivement les moyennes dans les variables M1, M2 et M3, cela donnera :
M1 ← Moy (Riri, 43);

M2 ← Moy (Fifi, 5);
M3 ← Moy (Fifi, k);
Le plus important, c'est d'acquérir le réflexe de constituer systématiquement les
fonctions adéquates quand on doit traiter un problème donné.
Cette partie de la réflexion s'appelle d'ailleurs l'analyse fonctionnelle d'un problème,

et c'est toujours par là qu'il faut commencer : en gros, dans un premier temps, on découpe le
traitement en modules, et dans un deuxième temps, on écrit chaque module. Cependant, avant
d'en venir là, il nous faut découvrir un dernier outil, qui prend le relais là où les fonctions
deviennent incapables de nous aider.
III.) Sous-Procédures
Les fonctions, c'est bien, mais dans certains cas, ça ne nous rend guère service. Il peut
en effet arriver que dans un programme, on ait à réaliser des tâches répétitives, mais que ces
tâches n'aient pas pour rôle de générer une valeur particulière, Prenons deux exemples.

Page 9
Premier exemple. Imaginons qu'au cours d’une application, on doit plusieurs fois
besoin d'effacer l'écran et de réafficher un bidule comme un petit logo en haut à gauche. On
pourrait se dire qu'il faut créer une fonction pour faire cela. Mais quelle serait la valeur
renvoyée par la fonction ? Aucune ! Effacer l'écran, ce n'est pas produire un résultat stockable
dans une variable, et afficher un logo non plus. Voilà donc une situation qu’on a besoin de
répéter du code, mais où ce code n'a pas comme rôle de produire une valeur.
Deuxième exemple. Au cours d’une autre application, on doit plusieurs fois faire saisir
un tableau d'entiers (mais à chaque fois, un tableau différent). Là encore, on serait tenté
d'effectuer toutes ces saisies de tableaux dans une seule fonction. Mais problème, une
fonction ne peut renvoyer qu'une seule valeur à la fois. Elle ne peut donc renvoyer un tableau,
qui est une série de valeurs distinctes.
Alors, dans ces deux cas, faute de pouvoir traiter l'affaire par une fonction, devra-t-on
en rester au code répétitif dont nous venons de dénoncer si les faiblesses ? Non, il y a une
solution qui consiste à utiliser des sous-procédures.
En fait, les fonctions - que nous avons vues - ne sont qu'un cas particulier des sous-
procédures - que nous allons voir : celui où doit être renvoyé vers la procédure appelante
une valeur et une seule. Dans tous les autres cas, il faut donc avoir recours non à la forme
particulière et simplifiée (la fonction), mais à la forme générale (la sous-procédure).
Parlons donc de ce qui est commun aux sous-procédures et aux fonctions, mais aussi
de ce qui les différencie. Voici comment se présente une sous-procédure ::
Procédure Bidule( ... )

...
Fin Procédure
Dans la procédure principale, l’appel à la sous-procédure Bidule devient quant à lui :
Appeler Bidule(...)
Etablissons un premier état des lieux.
• Alors qu'une fonction se caractérisait par les mots-clés Fonction ... Fin
Fonction, une sous-procédure est identifiée par les mots-clés Procédure ... Fin
Procédure.
• Lorsqu'une fonction était appelée, sa valeur (retournée) était toujours affectée à
une variable. L'appel à une procédure, lui, est au contraire toujours une instruction
autonome. "Exécute la procédure Bidule" est un ordre qui se suffit à lui-même.
• Toute fonction devait, pour cette raison, comporter l'instruction "Renvoyer".
Pour la même raison, l'instruction "Renvoyer" n'est jamais utilisée dans une sous-

Page 10
procédure. La fonction est une valeur calculée, qui renvoie son résultat vers la
procédure principale. La sous-procédure, elle, est un traitement ; elle ne "vaut" rien.
En effet, il nous reste à examiner ce qui peut bien se trouver dans les parenthèses, à la
place des points de suspension, aussi bien dans la déclaration de la sous-procédure que dans
l'appel. C'est là que vont se trouver les outils qui vont permettre l'échange d'informations entre
la procédure principale et la sous-procédure. Dans une fonction, les valeurs qui circulaient
depuis la procédure (ou la fonction) appelante jusqu'à la fonction portaient le nom
d'arguments. Là, les valeurs qui circulent depuis la procédure (ou la fonction) appelante vers
la sous-procédure appelée se nomment des paramètres en entrée de la sous-procédure. Mais
seul le nom change : "paramètres en entrée" pour les procédures ou "arguments" pour les
fonctions, on parle en fait exactement de la même chose.
Inversement, dans une fonction, la valeur retournée par la fonction portait le nom de la
fonction elle-même, et elle faisait l'objet d'une instruction spéciale ("renvoyer"). Avec une
sous-procédure, les valeurs retournées, quand il y en a, s'appellent des paramètres en sortie de
la sous-procédure, qui doivent être déclarés explicitement comme tels.
Ceci nous permet de reformuler en termes un peu différents la vérité fondamentale

apprise un peu plus haut : toute sous-procédure possédant un et un seul paramètre en sortie
peut également être écrite sous forme d'une fonction (et entre nous, c'est préférable car un peu
plus facile).
Il ne vous reste plus qu'une seule chose à savoir avant de pouvoir passer à la pratique.
C'est que dans la plupart des langages, on ne parlera pas de paramètres "en entrée" ou "en
sortie", mais de "paramètres transmis :
par valeur (correspondant à un paramètre en entrée)

par référence (correspondant à un paramètre en sortie)
On peut également imaginer le cas d’un paramètre qui serait passé à une procédure à
la fois en entrée et en sortie : on envoie une variable à une procédure, afin qu’elle la traite et
la renvoie modifiée. Dans ce cas, le paramètre aura également le statut d’une transmission par
référence (qui peut le plus peut le moins).
Tout cela peut sembler un tantinet compliqué. Mais sur le principe, c'est en réalité
assez simple, et dès que vous aurez pratiqué un peu, vous ferez cela les yeux fermés.
Reprenons le cas d'un programme au cours duquel on a plusieurs tableaux d'entiers à faire
saisir par l'utilisateur. Puisqu'un tableau comporte plusieurs valeurs, nous savons qu'il ne peut,
par définition, être renvoyé par une fonction. Mais une sous-procédure, elle, comporte autant
de paramètres en sortie qu'on veut. Elle peut donc sans problème renvoyer un tableau vers la
procédure qui l'appelle. Ecrivons donc notre sous-procédure :

Page 11
Procédure SaisieTab(T() en numérique par référence, N en entier par valeur)

Pour i ← 0 à N-1
Ecrire ("Saisie de la valeur n° ", i + 1);
Lire T(i);
Fin Procédure
Et son appel :
Tableau Truc(5), Machin(12) en Entier

...
Appeler SaisieTab (Truc, 5)
...
Appeler SaisieTab (Machin, 12)
...
Fin Procédure
La seule chose à remarquer, c'est que les variables manipulées par la sous-procédure
(notamment le tableau T) ne sont pas celles qui sont manipulées dans la procédure
appelante (les tableaux Truc et Machin).
Ceci n'est pas une obligation : on pourrait imaginer une architecture où ce seraient les
mêmes variables qui seraient triturées dans la procédure appelante et dans la sous-procédure
(ces variables porteraient alors le même nom). Mais une telle architecture, si elle est possible,
doit rester l'exception à laquelle on n'a recours qu'en cas de besoin très particulier. En effet,
pour qu'une telle chose soit possible, il faut que la variable ait la capacité de conserver sa
valeur d'une procédure à l'autre ; en quelque sorte, qu'elle survive même si la procédure qui la
manipulait se termine. Ce genre de variable dopée à l'EPO existe, on en reparlera dans un
instant, mais elle est très gourmande en ressources mémoire. Donc, comme toujours, vous
connaissez la chanson, on applique le principe de l'économie de moyens.
Conclusion : une sous-procédure est un morceau de code qui comporte éventuellement

des paramètres en entrée (transmis par valeur) et des paramètres en sortie (transmis par
référence). La sous-procédure manipule donc des variables qui lui sont propres, et la
procédure appelante agit de même. La présence des paramètres dans l'appel à la sous-
procédure et dans le titre de celle-ci assure le fait que la valeur des uns sera recopiée dans les
autres (transmission par valeur) et qu'en retour, celle des autres sera recopiée dans les uns
(transmission par référence).
IV.) Travaux dirigés

Objectifs

Page 12
Appliquer la démarche de programmation modulaire pour construire des

algorithmes structurés en procédures et fonctions
Savoir le mode de passage de paramètre d'une procédure et une fonction
Apprendre et distinguer l'appel d'une procédure et une fonction
Exercice 1
Ecrire une procédure puissance qui calcule c = a b = a x a x a x …x a
(b fois); a et b étant des entiers positifs. Tester cette procédure
Exercice 2
Ecrire une procédure permut qui permet d'échanger les valeurs de 2 entiers a et b.
Tester cette procédure
Exercice 3
Ecrire une fonction minimum qui retourne le minimum de 2 entiers a et b.
Tester cette fonction
Exercice 4.
On appelle bigramme une suite de deux lettres.

Ecrire une procédure qui calcule le nombre d'occurrences d'un bigramme dans une chaîne de caractères.
Peut-on transformer cette procédure en fonction? Si oui écrire cette fonction.
Exercice 5
Ecrire une fonction Triangle qui permet de vérifier si les 3 nombres a, b et c peuvent être les
mesures des côtés d'un triangle rectangle.
Remarque:
D'après le théorème de Pythagore, si a, b et c sont les mesures des côtés d'un rectangle, alors a 2 = b 2+ c 2
ou b 2 = a 2 + c 2 = a 2 + b 2
Exercice 6
Exercice une procédure ou une fonction permettant de saisir deux nombres puis qui affiche la
valeur absolue de leur différence.
Page 13
Exercice 7
Ecrire une procédure ou une fonction qui récupère un réel x puis affiche la valeur de la
fonction suivante :
2
+ +1
f = #−1; = −30
+1
Exercice 8
Développer une procédure ou une fonction qui calcule la suite numérique suivante
+ = + ∊
Exercice 8
Développer une fonction qui prend trois paramètres de type entier puis qui retourne le plus
grand
Exercice 9
Développer une procédure ou une fonction qui calcule la fonction suivante

2
− 2 −1
f = 2+1
≥0; = | 15 + 20 |
Exercice 10
Développer une procédure qui résous une équation de premier degré.

Page 14
Chapitre 2 TECHNIQUES DE TRIS
Objectif général : Bien comprendre les techniques de tris
Etre capable de:
Connaitre le tris à bulle

Connaitre le tris par selection
Exercice : 1, 2.
I.) Les tris a bulle
A) Spécification abstraite
Son principe est de parcourir la liste (a1, a2, ..., an) en intervertissant toute paire d'éléments
consécutifs (ai-1, ai) non ordonnés. Ainsi après le premier parcours, l'élément maximum se
retrouve en an. On suppose que l'ordre s'écrit de gauche à droite (à gauche le plus petit
élément, à droite le plus grand élément).
On recommence l'opération avec la nouvelle sous-suite (a1, a2, ..., an-1), et ainsi de suite
jusqu'à épuisement de toutes les sous-suites (la dernière est un couple).
Le nom de tri à bulle vient donc de ce qu'à la fin de chaque itération interne, les plus grands
nombres de chaque sous-suite se déplacent vers la droite successivement comme des bulles de
la gauche vers la droite.
B) Spécification concrète
La suite (a1, a2, ... , an) est rangée dans un tableau T[...] en mémoire centrale. Le tableau
contient une partie triée (en violet à droite) et une partie non triée (en blanc à gauche). On
effectue plusieurs fois le parcours du tableau à trier; le principe de base étant de ré-ordonner
les couples (ai-1, ai) non classés (en inversion de rang soit ai-1 > ai) dans la partie non triée
du tableau, puis à déplacer la frontière (le maximum de la sous-suite (a1, a2, ... , an-1)) d'une
position :

Page 15
Tant que la partie non triée n'est pas vide, on permute les couples non ordonnés ( (ai-1, ai)
tels que ai-1 > ai) ) pour obtenir le maximum de celle-ci à l’élément frontière. C'est à dire
qu'au premier passage c'est l'extremum global qui est bien classé, au second passage le second
extremum etc...
Algorithme :
Algorithme Tri_a_Bulles
local: i , j , n, temp  Entiers naturels
Entrée : Tab  Tableau d'Entiers naturels de 1 à n éléments
Sortie : Tab  Tableau d'Entiers naturels de 1 à n éléments
début
pour i de n jusquà 1 faire // recommence une sous-suite (a1, a2, ... , ai)
pour j de 2 jusquà i faire // échange des couples non classés de la sous-suite
si Tab[ j-1 ] > Tab[ j ] alors // aj-1et aj non ordonnés
temp  Tab[ j-1 ] ;
Tab[ j-1 ]  Tab[ j ] ;
Tab[ j ]  temp //on échange les positions de aj-1et aj
Fsi
fpour
fpour
Fin Tri_a_Bulles
Exemple : soit la liste ( 5 , 4 , 2 , 3 , 7 , 1 ), appliquons le tri à bulles sur cette liste d'entiers.
Visualisons les différents états de la liste pour chaque itération externe contôlée par l'indice i :
i = 6 / pour j de 2 jusquà 6 faire

Page 16
i = 1 / pour j de 2 jusquà 1 faire (boucle vide)
II.) Tris par sélection
A) Spécification abstraite
La liste (a1, a2, ... , an) est décomposée en deux parties : une partie triée (a1, a2, ... , ak) et
une partie non-triée (ak+1, ak+2, ... , an); l'élément ak+1 est appelé élément frontière
(c'est le premier élément non trié).
Le principe est de parcourir la partie non-triée de la liste (ak+1, ak+2, ... , an) en cherchant
l'élément minimum, puis en l'échangeant avec l'élément frontière ak+1, puis à
déplacer la frontière d'une position. Il s'agit d'une récurrence sur les minima
successifs. On suppose que l'ordre s'écrit de gauche à droite (à gauche le plus petit
élément, à droite le plus grand élément).
On recommence l'opération avec la nouvelle sous-suite (ak+2, ... , an) , et ainsi de

suite jusqu'à ce que la dernière soit vide.
Page 17
B) Spécification concrète
La suite (a1, a2, ... , an) est rangée dans un tableau T[...] en mémoire centrale. Le tableau
contient une partie triée (en violet à gauche) et une partie non triée (en blanc à droite).
On recopie le minimum de la partie non-triée du tableau dans la cellule frontière (le
premier élément de cette partie).
si ak+1 > ap alors ak+1 <--- ap Fsi
et l'on obtient ainsi à la fin de l'examen de la sous-liste (ak+1, ak+2, ... , an) la valeur
min(ak+1, ak+2, ... , an) stockée dans la cellule ak+1. La sous-suite (a1, a2, ... , ak,
ak+1) est maintenant triée et l'on recommence la boucle de recherche du minimum sur
la nouvelle sous-liste (ak+2, ak+3, ... , an) etc...
Tant que la partie non triée n'est pas vide, on range le minimum de la partie non-triée dans
l’élément frontière.
C) Algorithme :
Une version maladroite de l'algorithme mais exacte a été fournie par un groupe d'étudiants
elle est dénommée /version 1/. Elle échange physiquement et systématiquement
l'élément frontière Tab[ i ] avec un élément Tab[ j ] dont la valeur est plus petite (la
suite (a1, a2, ... , ai) est triée) :
Algorithme Tri_Selection /Version 1/

local: m, i , j , n, temp Î Entiers naturels
Entrée : Tab Î Tableau d'Entiers naturels de 1 à n éléments
Sortie : Tab Î Tableau d'Entiers naturels de 1 à n éléments

Page 18
pour i de 1 jusquà n-1faire // recommence une sous-suite

m ¬ i ; // i est l'indice de l'élément frontière Tab[ i ]
pour j de i+1 jusquà n faire// liste non-triée : (ai+1, a2, ... , an)
si Tab[ j ] < Tab[ m ] alors // aj est le nouveau minimum partiel
m¬j;
temp ¬ Tab[ m ] ;
Tab[ m ] ¬ Tab[ i ] ;
Tab[ i ] ¬ temp //on échange les positions de ai et de aj
m¬i;
Fsi
fpour
fpour
Fin Tri_Selection
Voici une version correcte et améliorée du précédent (nous allons voir avec la notion de
complexité comment appuyer cette intuition d'amélioration), dans laquelle l'on sort
l'échange ai et aj de la boucle interne "pour j de i+1 jusqu’ à n faire" pour le déporter
à la fin de cette boucle.
Assistants interactif animé version correcte :

liAu lieu de travailler sur les contenus des cellules de la table, nous travaillons sur les
indices, ainsi lorsque aj est plus petit que ai nous mémorisons l'indice "j" du minimum
dans une variable " m ¬ j ; " plutôt que le minimum lui-même. A la fin de la boucle
interne "pour j de i+1 jusquà n faire" la variable m contient l'indice de min(ai+1, ak+2,
... , an) et l'on permute l'élément concerné (d'indice m) avec l'élément frontière ai :
Algorithme Tri_Selection /Version 2/

local: m, i , j , n, temp Î Entiers naturels
Entrée : Tab Î Tableau d'Entiers naturels de 1 à n éléments
Sortie : Tab Î Tableau d'Entiers naturels de 1 à n éléments
pour i de 1 jusquà n-1faire // recommence une sous-suite

m ¬ i ; // i est l'indice de l'élément frontière ai = Tab[ i ]
pour j de i+1 jusquà n faire// (ai+1, a2, ... , an)
si Tab[ j ] < Tab[ m ] alors // aj est le nouveau minimum partiel
m ¬ j ; // indice mémorisé

Page 19
Fsi
fpour;
temp ¬ Tab[ m ] ;
Tab[ m ] ¬ Tab[ i ] ;
Tab[ i ] ¬ temp //on échange les positions de ai et de aj
fpour
Fin Tri_Selection
III.) Travaux dirigés
Exercice 1
Développer une procédure, qui permet de saisir 100 réels puis qui les affiche dans l'ordre
inverse de leur saisie.
Exercice 2
Développer une procédure qui permet de saisir 100 réels puis qui les affiche dans l'ordre
croissant.
NB : Vous devez implémenter les techniques des tris à bulle et par sélection

Page 20
Chapitre 3 TECHNIQUES DE RECHERCHE DANS UN VECTEUR
Objectif général : Bien comprendre les techniques de recherche dans un vecteur
Objectif spécifique : Bien maitriser les techniques de recherche séquentielle et dichotomique
Exercice: 1, 2, et 3.
I.) Recherche séquentielle linéaire
Il s'agit de rechercher un élément dans un vecteur en effectuant un parcours séquentiel. La

fonction correspondante est la suivante.
fonction recherche_sequentielle(V: vecteur, n, val, pos: entier): booléen

début
i←2
tant que i<=N et val≠V[1] faire
i←i+1
fin tant que
si val=V[i] alors
recheche-sequentielle ← vraie
pos ← i
sinon
recherche-sequentielle ← faux
fin si
fin
Temps favorable (Tn)

TN=3TC
vals = 7
7 4 2 1 3 5
V:

Page 21
II.) Recherche séquentielle avec sentinelle
fonction recherche_sequentielle(V: vecteur, N, val, pos: entier): booleen

var i: entier
debut
V[N+1] ← val
i ← i+1
fin tant que
si i<=N alors
recherche_sequentielle ←- vraie
pos ← i
sinon
recherche_sequentielle ← faux
fin si
fin
III.) Recherche dichotomique
La recherche dichotomique suppose que le vecteur dans lequel on recherche une valeur "val"
donnée est triée. Supposons que le vecteur est trié dans l'ordre croissant. Soit "min" et "max"
les valeurs minimales et maximales de l'ensemble des indices du vecteur V. Le principe de la
recherche dichotomique est le suivant:

Page 22
1. Calculer le milieu
mil = (min+max)/2
2. Si V du milieu = val V[mil]=val alors on arrête la recherche car on a trouvé "val".
3. Si V[mil]>val alors on continue la recherche dans la partie de V donc les indices
varies entre "min" et "mil".
4. Si V[mil]<val alors on continue la recherche dans la partie de V donc les indices
varies entre "mil" et "max"
5. Temps qu'on n'a pas trouvé val reprendre toute ces actions à partir de la première
jusqu'à l'obtention d'un intervalle de recherche de taille "1".
S'il n'y a pas toujours égalité alors la valeur recherchée n'existe pas dans le vecteur.
fonction rech(V: vecteur, n, val, pos: entier): booléen

var, mil, min, max: entier
trouve: booléen
debut
min ← 1
max ← n
trouve ← faux
tant que (min < max) et (non trouve) faire
mil ← (min+max)div2
si val < V[mil] alors
max ← mil
sinon
si val > V[mil] alos
mil ← mil+1
fin si
trouve ← val=V[mil]
fin tant que
rech ← trouve
fin

Exercice 1
Que fait l’algorithme suivant

Page 23
Tableau Tab(20) :entier;

Variable N : entier;
Début
Ecrire ("Entrez la valeur à rechercher");
Lire (N);
Trouvé ← Faux;
Pour i ← 0 à 19 faire
Si (N = Tab(i)) Alors
Trouvé ← Vrai;
FinSi
Finpour
Si Trouvé Alors
Ecrire ("N fait partie du tableau");
Sinon
Ecrire ("N ne fait pas partie du tableau");
FinSi
Fin
Exercice 2
Développer l'algorithme qui permet de saisir et de stocker 100 réel puis qui affiche sa valeur
du plus petit ainsi que sa position d'apparition (numéro d'ordre).
Exercice 3
1) Développer une procédure qui permet de saisir 100 réels
2) Développer une procédure qui prend en paramètre un tableau des 100 réels saisis ci-
dessus puis qui les tris
3) Développer Une fonction renvoyant un booléen, qui prend en paramètre la tableau des
100 réels saisis ci-dessus, et un nombre qui sera recherché dans ce tableau à travers la
méthode dichotomique.

Page 24
Chapitre 4 NOTION DE COMPLEXITE DES ALGORITHMES INFORMATIQUES
Objectif général : Bien comprendre les notions de complexité des algorithmes
Etre capable de:
Définir les notions de complexité

Connaitre les types de complexité
Déterminer la complexité des algorithmes
Exercice : 1, 2, 3
Introduction
L’objectif de ce chapitre est de léguer aux étudiants des connaissances devant leur permettre
d’être capable d’évaluer les performances d’un algorithme (temps d’exécution ou espace
mémoire). Le but est d’être capable d’évaluer la complexité des algorithmes. Plusieurs
algorithmes seront soumis à votre sagacité. Ainsi les étudiants devront être capables d’évaluer
la complexité de ces algorithmes.
I.) Définition des notions de complexité en espace et temps d’exécution

La complexité en espace correspond à l’espace mémoire (nombre d’octets) nécessaire à
l’exécution sur une donnée de taille N
La complexité en temps correspond au temps d’exécution (nombre d’opérations

élémentaires) de l’algorithme sur une donnée de taille N
II.) Détermination de la complexité
a.) Cas N° 1 : Algorithme qui permute deux nombres.

TAF : Evaluation la complexité de chacune des solutions et enfin opérons le choix de
l’algorithme le plus performant
Solution 1 Solution 2
// échange des valeurs de deux variables // échange des valeurs de deux variables
entier x, y, z; entier x, y;
Par... Serge DOUMI
// initialisation de x et y Ingénieur Génie Logiciel & Expert IT
... // initialisation de x et y
z <- x; Certifié : ITIL V3, SQL, CCNA
x <- y-x; et Oracle
x <- y; Web: www.sergedoumi.net
y <- y-x;
Page 25
y <- z; x <- y+x;
Cas de la solution 1
Utilisation de trois variables et donc nécessité de trois espaces mémoires en mémoire centrale,
ensuite l’algorithme fait trois affectations. Donc sa complexité est d’ordre 3 notée O(3).
Cas de la solution 2
Utilisation de deux variables et donc nécessité de deux espaces mémoires, mais ici en plus de
trois affections, on a aussi trois opérations arithmétiques. Et donc sa complexité est d’ordre 6
notée O(6)
Conclusion l’algorithme le plus performant en terme de temps d’exécution est celui de la

solution 1
b.) Cas N°2 : Algorithme qui calcule le factorielle d’un nombre

Fonction factorielle (entier n) : entier
Var i, resultat : entier ;
Début
resultat <- 1;
pour (i allant de 2 à n) faire
resultat <- resultat*i;
finpour
retourne resultat;
Fin
TAF : Déterminons la complexité de cet algorithme
Cet algorithme possède plusieurs types d’instructions parmi lesquels
L’affection : qui resultat <- 1; noté par exemple par t

L’affection : via l’instruction resultat <- resultat*i; noté par exemple par p
L’instruction arithmétique via resultat*i; note par exemple par k
Maintenant nous réalisons que dans la bouche le processeur exécute les instructions p et k (n-1) fois.
Donc la complexité de cet algorithme est : O (t+ (n-1) [k+p]) qui est égale à O[t+ (n-1) p]
III.) Types de complexité

Algorithmes on peut distinguer plusieurs types de complexité comme en occurrence :
O(1) : complexité constante, pas d'augmentation du temps d'exécution quand le paramètre croit
O(n) : complexité linéaire, augmentation linéaire du temps d'exécution quand le
paramètre croit (si le paramètre double, le temps double). Exemple : algorithmes qui
parcourent séquentiellement des structures linéaires.
Page 26
O(ni) : complexité polynomiale, quand le paramètre double, le temps d'exécution est

multiplié par 2i. Exemple : algorithme utilisant i boucles imbriquées.
O(in) : complexité exponentielle, quand le paramètre double, le temps d'exécution est
élevé à la puissance 2.
O(n!) : complexité factorielle, asymptotiquement équivalente à n
Exercice 1
Déterminer la complexité de la fonction suivante
Fonction RecherchePositionClient (T : VECTEUR_CLIENT, clt_to_find : chaine, Nbre :entier) :
réel ;
Var position: réel ;
Début
position ← -1*1 ; // initialise à la valeur négative -1
Si Nbre < = 200 alors
Pour i←1 à Nbre faire
Si T[i].codeclt = clt_to_find alors
position ← i ;
Finsi
Finpour
Finsi
RecherchePositionClient ← position ;
FinFonction
Exercice 2
Déterminer la complexité des portions de code suivante
Cas N° 3
Cas N° 1 Cas N° 2
Pour i de 1 à n faire
Pour i de 1 à n faire Pour i de 5 à n-5 faire
Pour j de i à n faire
Pour j de 1 à n faire Pour j de i-5 à i+5 faire
Pour k de 1 à j faire
x =x+3 ; x =x+a ;
Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT x =x+a ;
Page 27
Chapitre 5 LA RECURCIVITE
Objectif général : Bien comprendre la récursivité
Etre capable de:
Définir les notions de récursivité

Connaitre les types de récursivité
Développer des algorithmes récursifs
Exercice : 1, 2, 3, 4 et 5
I.) Introduction
La récursivité est une notion importante de la programmation qui permet de régler des
problèmes extrêments complexes avec seulement quelques lignes. C’est cependant une
méthode avec laquelle il est facile de se perdre et d’avoir des résultats imprévisibles ou
erronés. Cependant la récursivité est bien utilisée, c’est cependant un outil simplifiant, lisible,
efficace et souvent sous-estimé.
II.) Fonction définies récursivement

On est souvent inciter à appeler une fonction à partir d’elle-même. Cette façon récurrente de
faire permet non seulement de définir des fonctions mais aussi des ensembles et des suites.
Pour définir une fonction sur l’ensemble des entiers positifs on procède de la manière
suivante :
On précise la valeur de la fonction zéro
On donne la règle pour trouver la valeur de la fonction à partir de sa ou de ses valeurs
précédentes. Cette façon récurrente de faire appeler la récursivité est conséquence de
l’induction mathématique (preuve par induction). Les exemples que nous aborderions ci-
dessous élucideront nos propos.
III.) Quelques exemples

La suite des puissances de 2 définit par an =2n pour n=0, 1, 2 …….
On peut définir une forme récursive en donnant le premier élément a0 = 1 (la base) et une
relation de la récurrente telle que an+1= 2. an
le factoriel d’un nombre n noté n ! ce qui signifie 1 * 2*3*3*4*…………………*n
Donc le premier élément fo=1 (la base) et la relation de récurrente fn+1 = (n+1)*fn
Série de Fibonacci : En utilisant l’approche récursive pour trouver le n-ième nombre de
Fibonacci. Les amorces (base) sont : f(0) = 0 et f(1) = 1 et la relation de récurrente est f(n)
Page 28
=f(n-1) + f(n-2) Exemple 377= 233+144) d’où la série 0 ; 1 ; 2 ; 3 ; 5 ; 8 ; 13 ; 21 ; 34 ; 55 ;

89 ; 144 ; 233 ; 377 ; 610
IV.) Types de récursivité

Il existe plusieurs types de récursivité :
récursivité simple : un algorithme récursif est simple ou linéaire si chaque cas se
résout en au plus un appel récursif. Le calcul de la factorielle en est un exemple
récursivité multiple : un algorithme récursif est multiple si l’un des cas qu’il distingue
se résout avec plusieurs appels récursifs. Si "plusieurs=2" on parle de récursivité
binaire. Les tours de Hanoï est un problème qui se résout en récursivité binaire.
récursivité croisée : deux algorithmes sont mutuellement récursifs si l’un fait appel à
l’autre et l’autre fait appel à l’un. On parle aussi de récursivité croisée.
récursivité terminale : un algorithme est récursif terminal si l’appel récursif est la
dernière instruction de la fonction. La valeur retournée est directement obtenue par un
appel récursif.
récursivité imbriquée : Un algorithme est récursif imbriqué si l’appel récursif contient
lui aussi un appel récursif. La fonction d’Ackermann en est un exemple :
V.) Travaux dirigés

Exercice 1
Ecrire une fonction récursive qui retourne la somme des chiffres d’un entier N donné Exemples 123
implique 1+2+3
Exercice 2
Ecrire une fonction récursive qui calcule le factoriel d’un entier N positif.
Exercice 3
Ecrire une fonction récursive qui permet de connaitre si un entier N saisir au clavier est premier ou pas
Exercice 4
Ecrire une fonction récursive qui permet de calculer la suite de Fibonacci donner par f(n) =f(n-1) + f(n-2)
Exercice 5
n
Ecrire une fonction récursive qui calcule x (x et n étant des entiers positifs)

Page 29

Structure de Données Avancées

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Structure de Données Avancées

Transféré par

Droits d'auteur :

Formats disponibles

Support de cours de Structure de Données Avancées BTS Option GL Niv 2

La connaissance ne signifie pas

Elle est une combinaison de trois

1) Le savoir savant : Je sais que

3) Le savoir être : Je sais

STRUCTURE DE DONNEES AVANCEES I

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

A la fin de ce module l’étudiant sera capable de :

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Tables des Matières

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Chapitre 1 PROCEDURES ET FONCTIONS

Objectif général : Bien comprendre les procédures et les fonctions

Etre capable de:

Expliquer l’intérêt des procédures et fonctions

I.) De quoi s'agit-il ?

La manière la plus évidente, mais aussi la moins habile, de programmer ce genre de

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Le corps du programme s’appelle alors la procédure principale, et ces groupes

On le voit bien, il y a là une répétition quasi identique du traitement à accomplir. A

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

II.) Les fonctions

On remarque au passage l’apparition d’un nouveau mot-clé : Renvoyer, qui indique

Ecrire ("Etes-vous marié ?");

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

En langage algorithmique, on dira que le message devient un argument de la

Fonction RepOuiNon (Msg : char) :char

Rep1 ← RepOuiNon ("Etes-vous marié ?");

Rep2 ← RepOuiNon ("Avez-vous des enfants ?");

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Imaginons qu'à plusieurs reprises au cours du programme, on ait à calculer la moyenne

• Comment calculer la moyenne de ses éléments ?

Voilà donc une situation où la fonction a absolument besoin de deux arguments.

Fonction Moy (T() : entier, n en Entier) :entier

M1 ← Moy (Riri, 43);

Cette partie de la réflexion s'appelle d'ailleurs l'analyse fonctionnelle d'un problème,

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Procédure Bidule( ... )

Dans la procédure principale, l’appel à la sous-procédure Bidule devient quant à lui :

Etablissons un premier état des lieux.

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Ceci nous permet de reformuler en termes un peu différents la vérité fondamentale

par valeur (correspondant à un paramètre en entrée)

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Procédure SaisieTab(T() en numérique par référence, N en entier par valeur)

Tableau Truc(5), Machin(12) en Entier

Conclusion : une sous-procédure est un morceau de code qui comporte éventuellement

IV.) Travaux dirigés

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Appliquer la démarche de programmation modulaire pour construire des

Savoir le mode de passage de paramètre d'une procédure et une fonction

Apprendre et distinguer l'appel d'une procédure et une fonction

On appelle bigramme une suite de deux lettres.

Peut-on transformer cette procédure en fonction? Si oui écrire cette fonction.

Développer une procédure ou une fonction qui calcule la fonction suivante

Développer une procédure qui résous une équation de premier degré.

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Chapitre 2 TECHNIQUES DE TRIS

Objectif général : Bien comprendre les techniques de tris

Etre capable de:

Connaitre le tris à bulle

I.) Les tris a bulle

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT