Vous êtes sur la page 1sur 93

Ministre de lEnseignement Suprieur et de la Recherche Scientifique

Direction Gnrale des tudes Technologiques





















AU 2009-2010
(Semestre 2)
SUPPORT DE COURS
Algorithmique et structures des donnes 2
Enseignants :
Ahlem Tayachi
Fatma Laribi
Maali Ben Khadija
Nesrine Ben Hadj Hammouda
Sameh Mansouri




Prsentation du cours

Fiche matire
Domaine de formation : Sciences et technologies
Mention : Technologie de linformatique (TI)
Parcours : Tronc Commun
Semestre : S2
Unit denseignement : Programmation et structures dynamiques
Volume horaire : 45 heures (22,5 cours 22,5 TD)
Coefficient : 2
Rsum du cours
Le cours dalgorithmique et structure de donnes est destin aux tudiants de premire
anne du tronc commun de loption Technologies de lInformatique.
Ce cours dfinit les enregistrements et la faon de les utiliser afin de pouvoir matriser par
la suite les structures de donnes dynamiques.
Il introduit ensuite les types de donnes abstraits pour pouvoir les implmenter dans la
reprsentation des donnes et les diffrentes oprations associes.
Aprs avoir spcifier le type de donne abstrait, ce cours prsente les structures linaires
simples, telles que les listes, les piles et les files pour terminer par des structures pour des
structures plus complexes telles que les graphes et les arbres.
Enfin, ce cours introduit la notion de complexit algorithmique en donnant un aperu sur
la complexit de quelques algorithmes.
Mentionnons que ce cours ncessite comme pr-requis lalgorithmique et structures de
donnes 1.
Objectifs gnraux
Ce cours vise approfondir les comptences acquises par lapprenant en
algorithmique.
Savoir crire des algorithmes se rapportant des structures dynamiques : listes, piles,
files, arbres, etc.
Etre capable de transformer un schma itratif simple en un schma rcursif.




Pr-requis
Algorihtmique1
Programmation1
Evaluation
Interrogation Orale
Un devoir surveill dune heure
Examen Final crit de 2 heures sur tout le programme
Moyens Pdagogiques
Expos informel
Tableau
Support du cours
Travaux dirigs

Mthodologie

Le cours sarticule autour de 2 types dactivits, les cours intgrs et les sances de
travaux dirigs.
Les sries dexercices sont distribus aux tudiants et corriges en classe.



SOMMAIRE
Chapitre1 : Les enregistrements
1.1 Les types ......................................................................................................................... 1
1.1.1 Les types de base ........................................................................................................ 1
1.1.2 Les types simples .......................................................................................................... 1
1.1.3 Les types complexes ................................................................................................ 1
1.2 Dfinition dun enregistrement .................................................................................... 2
1.2.1 Utilit ....................................................................................................................... 2
1.2.2 Dfinition ................................................................................................................. 2
1.2.3 Syntaxe ..................................................................................................................... 2
1.2.4 Reprsentation .......................................................................................................... 3
1.3 Utilisation dun enregistrement ................................................................................... 3
1.3.1 Dclaration ............................................................................................................... 3
1.3.2 Accs ........................................................................................................................ 3
1.3.3 Exemple ................................................................................................................... 4
1.4 Les types abstraits ......................................................................................................... 4
1.4.1 Dfinition ................................................................................................................. 5
1.4.2 Exemple : ................................................................................................................. 5
1.4.3 Signature dun type abstrait ..................................................................................... 5
1.5 Exercices dapplication .................................................................................................... 6
1.6 Solutions des exercices ...................................................................................................... 7
Chapitre 2: Les pointeurs
2.1 Rappel ........................................................................................................................... 10
2.1.1 Mmoire centrale (MC) ......................................................................................... 10
2.1.2 Structure de la mmoire centrale ........................................................................... 10
2.1.3 La notion dadresse ................................................................................................ 10
2.2 Les pointeurs ................................................................................................................ 10
2.2.1 Dfinition ............................................................................................................... 10
2.2.2 Dclaration dun pointeur ...................................................................................... 11
2.2.3 Cration dun pointeur ........................................................................................... 11
2.2.4 Utilisation dun pointeur ........................................................................................ 12


2.2.5 Suppression dune variable point ......................................................................... 13
2.2.6 Arithmtiques sur les pointeurs.............................................................................. 13
2.2.7 Les tableaux et les pointeurs .................................................................................. 16
2.2.8 Les chaines des caractres et les pointeurs ............................................................ 18
2.3 Exercices dapplication ............................................................................................... 18
2.4 Solution des exercices .................................................................................................. 20
Chapitre3: Les listes
3.1 Introduction ................................................................................................................. 27
3.2 Dfinition ...................................................................................................................... 27
3.3 Oprations sur les listes .............................................................................................. 27
3.4 Reprsentation ............................................................................................................. 28
3.4.1 Reprsentation graphique ....................................................................................... 28
3.4.2 Reprsentation des donnes ................................................................................... 28
3.5 Algorithmes de quelques oprations sur les listes ..................................................... 29
Chapitre4: Les piles et les files
4.1 Les piles ........................................................................................................................ 33
4.1.1 Prsentation ............................................................................................................ 33
4.1.2 Manipulation dune pile ......................................................................................... 34
4.2 Les Files ........................................................................................................................ 35
4.2.1 Prsentation ............................................................................................................ 35
4.2.2 Manipulation dune file .......................................................................................... 36
Chapitre5: La rcursivit
5.1 Rappel ........................................................................................................................... 39
5.1.1 Les procdures ....................................................................................................... 39
5.1.1.1 Dfinition ............................................................................................................. 39
5.1.1.2 Les variables et les paramtres ....................................................................... 40
5.1.1.3 Passage des paramtres ................................................................................... 41
5.1.2 Les fonctions .......................................................................................................... 42
5.1.2.1 Dfinition ........................................................................................................ 42
5.2 Algorithmes rcursifs .................................................................................................. 43
5.2.1 Dfinitions rcursives ............................................................................................ 43


5.2.2 Fonctions rcursives ............................................................................................... 44
5.2.2.1 Dfinition ........................................................................................................ 44
5.2.2.2 Excution dune fonction rcursive ................................................................ 44
5.2.2.3 Variables locales et paramtres des fonctions rcursives ............................... 45
5.3 Exercices dapplication ............................................................................................... 46
5.4 Solution des exercices .................................................................................................. 47
Chapitre6: Les arbres et les graphes
6.1 Les Arbres .................................................................................................................... 52
6.1.1 Dfinition ............................................................................................................... 52
6.1.2 Implmentation ...................................................................................................... 53
6.1.3 Les fonctions daccs ............................................................................................. 53
6.1.4 Niveau et hauteur dun arbre :................................................................................ 56
6.1.5 Parcours dun arbre ................................................................................................ 57
6.2 Les graphes .................................................................................................................. 59
6.2.1 Dfinition ............................................................................................................... 59
6.2.2 Implmentation : ......................................................................................................... 60
Chapitre7: Les algorithmes de recherche rcursifs
7.1 Dfinition ...................................................................................................................... 65
7.2 Recherche dans une liste chaine ............................................................................... 65
7.2.1 Recherche squentielle ........................................................................................... 65
7.2.2 Recherche par valeur .............................................................................................. 65
7.2.3 Recherche par position ........................................................................................... 66
7.2.4 Recherche dichotomique ........................................................................................ 66
7.2.5 Recherche dans une liste ordonne ........................................................................ 66
7.3 Recherche dans un arbre binaire ............................................................................... 69
7.3.1 Parcours en profondeur .......................................................................................... 69
7.3.1.1 Parcours prfix .............................................................................................. 69
7.3.1.2 Parcours infix ................................................................................................ 70
7.3.1.3 Parcours postfix ............................................................................................ 71
7.3.2 Application ............................................................................................................. 71
7.3.3 Arbre binaire de recherche ..................................................................................... 72


Chapitre8: Complexit des algorithmes
8.1 Introduction ................................................................................................................. 74
8.2 Dfinition ...................................................................................................................... 74
8.3 Calcul de la complexit ............................................................................................... 74
8.4 Type de complexit ...................................................................................................... 75
8.5 Complexit de quelques algorithmes ......................................................................... 76
8.5.1 Recherche du plus petit lment ............................................................................ 76
8.5.2 Produit de matrice .................................................................................................. 76
DS et examen




































Chapitre 1 :
Les enregistrements

Vue densemble
Cette leon prsente la dfinition et lutilisation des enregistrements.

Objectifs
Ce chapitre a pour objectifs de permettre aux tudiants dacqurir les connaissances de
base se rapportant aux objectifs spcifiques suivants:
Etre capable dutiliser et crer des nouveaux types de donnes selon le besoins du programme
(les enregistrements).
Savoir crire un enregistrement

Pr-requis
Algorithmique 1

Dure
3 H

Elments de contenu
1. Les types
2. Dfinition dun enregistrement
3. Utilisation dun enregistrement
4. Les types abstraits
5. Exercices dapplication
6. Solutions des exercices
Chapitre1 : Les enregistrements


@quipe pdagogique Algorithmique2 1

1.1 Les types
1.1.1 Les types de base
- Toute variable utilise dans un algorithme doit avoir un type qui caractrise lensemble de
valeur quelle peut prendre dans cet algorithme, ce type peut tre un type de base (prdfinit)
ou un type compos qui est dfinit par lutilisateur.
- Les types de base se divisent en 2 catgories : les types simples et les types complexe.
1.1.2 Les types simples
Les types de simple qui peuvent tre utilis pour reprsenter les variables dun algorithme
sont :
- Entier : la variable peut prendre des valeurs entires positives ou ngatives, pour utiliser ce
type on utilise le mot cl entier

- Reel : la variable peut prendre des valeurs relles, pour utiliser ce type on utilise le mot cl
reel

- Caractere : la variable peut prendre tout caractre quon peut saisir avec un clavier
standard, pour utiliser ce type on utilise le mot cl reel

- Booleen : la variable a 2 valeurs VRAI ou FAUX, pour utiliser ce type on utilise le mot cl
booleen
1.1.3 Les types complexes
Les types simples servent pour dfinir les types complexes qui permettent de reprsenter des
structures de donnes plus compliqus, ces types sont :
- Tableau :
o la variable est forme par lunion de plusieurs cases mmoire qui contiennent chacune
le mme type.
o la dclaration dun tableau se fait comme suit : nom : Tableau [i_deb .. i_fin] de
type .
o i_deb et i_fin reprsentent lindice de dbut et lindice de fin du tableau.
- Chane de caractre :
Chapitre1 : Les enregistrements


@quipe pdagogique Algorithmique2 2

o Cest la concatnation de plusieurs caractres qui finissent par le marqueur de fin de
chane. Cest ainsi un tableau de caractres qui contient comme dernier caractre un
caractre spcial pour reprsenter le marqueur de fin de chane.
o La dclaration se fait comme suit : nom : chaine [ Max ]
o Max est le nombre maximum de caractre.
1.2 Dfinition dun enregistrement
1.2.1 Utilit
Contrairement aux types de base les types composs sont dfinit par lutilisateur. Les types
de bases servent pour dfinir de nouveaux types composs. Ces nouveaux types servent pour
reprsenter des structures de donnes plus complexes quon ne peut pas reprsenter par les
types de bases.
Exemple :
Si on veut reprsenter les donnes relatives une personne telle que le nom et lge dans
une seule variable ou une seule structure de donne, on ne peut pas faire a avec les types de
bases et particulirement avec les tableaux. On peut utiliser un nouveau type appel
enregistrement qui contient 2 champs, un pour reprsenter le nom de type chane de
caractre et le 2
me
pour reprsenter lage de type entier. On remarque quon ne peut pas
reprsenter la personne par un tableau car elle est forme de 2 types diffrents.
Ainsi on dfinit le type personne par un enregistrement comme suit :
Personne = Enreg
nom : chane [30]
age : entier
FinEnreg
1.2.2 Dfinition
Lenregistrement est une structure de donnes (ou un type) compose, qui est form par
plusieurs autres structures de donnes de nature diffrentes. Il permet ainsi de les regrouper
dans une seule structure de donnes.
1.2.3 Syntaxe
Nom = Enreg
Champ1 : type
Chapitre1 : Les enregistrements


@quipe pdagogique Algorithmique2 3


Champs N : type
FinEnreg
On dsigne par :
- Nom : reprsente le nom de lenregistrement.
- Champs 1N : les noms des champs qui constituent lenregistrement.
- Type : est le type de chaque champ.
1.2.4 Reprsentation
Les enregistrements sont reprsents en mmoire sous forme de suite de zones contigus
qui servent chacune reprsenter les diffrents champs, ces zones sont de taille diffrentes
puisque chaque champ a un type diffrent. Par exemple lenregistrement personne sera
reprsenter en mmoire comme suit :
Octet 1 Octet 2 Octet 30 Octet
nom age

1.3 Utilisation dun enregistrement
1.3.1 Dclaration
La dclaration dun enregistrement se fait comme tant un nouveau type dfinit par
lutilisateur dans lalgorithme, il doit tre dclar dans la partie Type avant dtre utilis
comme type de variable dans la partie Var.
1.3.2 Accs
Lenregistrement qui est une structure de donnes compos de plusieurs champs nest pas
accessible dans sa totalit, donc pour faire un accs un enregistrement on accde tous les
champs un par un. Et pour utiliser un champ on crit le nom de la variable de type
enregistrement suivi de point suivi du champ auquel on veut accder :
Nom_enregistrement.champ_desire
Chapitre1 : Les enregistrements


@quipe pdagogique Algorithmique2 4

1.3.3 Exemple
On veut crire un algorithme qui lit le nom, le prnom et la moyenne gnrale dun
tudiant puis il affiche si cet tudiant a russi ou non selon que sa moyenne est >= 10 ou non.
Utiliser un enregistrement pour reprsenter ltudiant.
Algorithme Resultat
Type
Etudiant = Enreg
nom : chane [30]
prenom : chane [30]
MG : reel
R : caractere
FinEnreg
Var
E : Etudiant
Debut
Lire (E.nom)
Lire (E.prenom)
Lire (E.MG)
Si (E.MG >= 10) Alors
E.R 'A'
Ecrire (''Admis '')
Sinon
E.R 'R'
Ecrire (''Refus '')
FinSi
Fin
1.4 Les types abstraits
Les enregistrements permettent de reprsenter des structures de donnes complexes et
formes par des types non homognes. Mais ils ne prsentent pas une abstraction au niveau
des structures de donnes de lalgorithme. Pour rsoudre ce problme on fait recours une
gnralisation du type enregistrement par les types abstraits. Ce qui donne une indpendance
vis--vis dune implmentation particulire et les donnes sont considres dune manire
abstraite.
Chapitre1 : Les enregistrements


@quipe pdagogique Algorithmique2 5

1.4.1 Dfinition
Un type abstrait permet de reprsenter les donnes, les oprations faites sur ces donnes et
les proprits de ces oprations, dans une mme structure de donnes.
1.4.2 Exemple :
Si on veut reprsenter un Compte Bancaire par un type abstrait il sera compos des donnes et
des oprations concernant les Comptes Bancaires :
- Les donnes seront :
Une variable pour reprsenter le numro du compte
Une variable pour reprsenter le solde
Une variable pour reprsenter le nom du propritaire
- Les oprations sur les comptes bancaires:
Une fonction pour crer un nouveau compte
Une fonction pour consulter un compte
Une procdure pour dbiter un compte
Une procdure pour crditer un compte
- Les proprits des oprations :
Pour dbiter il faut que le solde soit positif
Seuls les salaris peuvent crer des comptes.
1.4.3 Signature dun type abstrait
La signature dun type abstrait de donnes est dfinie par :
Les noms des types utiliss pour reprsenter les donnes (rels, entiers, ).
Les noms des oprations et leurs profils.
La signature dcrit la syntaxe du type abstrait mais elle ne le dfinie pas rellement. Ainsi
pour lexemple prcdent la signature est :
- Les types des donnes :
entier
reel
chaine[20]
- les oprations et leurs profils :
Chapitre1 : Les enregistrements


@quipe pdagogique Algorithmique2 6

Creer_compte : chaine[20] entier
Consulter _compte : entier reel
Debiter : entier * reel
Crediter : entier * reel
1.5 Exercices dapplication
Exercice 1 : Saisie dune fiche
Une fiche contient les coordonnes suivantes:
-Nom (chane de caractres de longueur 10)
-Prnom (chane de caractres de longueur 10)
-Age (entier)
-Note (rel)
Ecrire un algorithme puis un programme C qui permet de crer la structure ci-dessus, saisir
une fiche et l'afficher.
Exercice 2 : Somme et produit de deux nombres complexes
Ecrire un algorithme puis un programme C qui lit deux nombres complexes C1 et C2 et qui
affiche ensuite leur somme et leur produit.
On utilisera les formules de calcul suivantes :
(a + bi)+(c + di) = (a + c) + (b + d)i
(a + bi)(c + di) = (ac - bd) + (ad + bc)i
Exercice 3 : Coordonnes dun point
Crer une structure Point qui contient les champs suivants :
num : entier
x et y : reel
Ecrire un programme C qui permet de saisir 4 points, les ranger dans un tableau puis les
afficher.
Exercice 4 : Tableau des employs
Ecrire un programme C qui permet de crer un tableau TabEmp qui contiendra les
informations sur les 10 employs dune entreprise (Matricule, Nom, Salaire, Etat_Civil), le
remplir puis afficher le nombre demploys dont le salaire est compris entre 500 et 700 D.

Chapitre1 : Les enregistrements


@quipe pdagogique Algorithmique2 7


1.6 Solutions des exercices
Exercice 1 :
Algorithme Saisie_Fiche
Type
fiche=enreg
nom : chaine[10]
prenom : chaine[10]
age : entier
note : reel
FinEnreg
Var
f : fiche
Dbut
Lire (f.nom)
Lire (f.prenom)
Lire (f.age)
Lire (f.note)
Ecrire (f.nom, f.prenom,f.age,f.note)
Fin
Exercice 2 :
Algorithme CalculComplexe
Type
Complexe=enreg
Re : Rel
Im : Rel
FinEnreg
Var
C1, C2, S, P : Complexe
Dbut
Ecrire ( Partie relle du premier nombre :)
Chapitre1 : Les enregistrements


@quipe pdagogique Algorithmique2 8

Lire (C1.Re)
Ecrire ( Partie imaginaire du premier nombre :)
Lire (C1.Im)
Ecrire ( Partie relle du deuxime nombre :)
Lire (C2.Re)
Ecrire ( Partie imaginaire du deuxime nombre :)
Lire (C2.Im)

S.Re = C1.Re + C2.Re
S.Im = C1. Im + C2.Im
Ecrire (Somme=, S.Re, +, S.Im, i)

P.Re = (C1.Re * C2.Re) (C1. Im * C2.Im)
P.Im = (C1.Re * C2.Im) + (C1. Im * C2.Re)
Ecrire (Produit=, P.Re, +, P.Im, i)
Fin
Exercice 4 :

Algorithme Personnel
Constantes
n = 50
Types
Employ=Struct
Matricule : Entier
Nom : Chane
Sal : Rel
Etat_Civil : Caractre
Fin Struct
Tab = Tableau [1..n] de Employ
Variables
TabEmp : Tab
I, nb : Entier
Chapitre1 : Les enregistrements


@quipe pdagogique Algorithmique2 9

Procdure Remplir (Var T :Tab)
Dbut
Pour i de1 n faire
Ecrire ( Matricule de lemploy :)
Lire (T[i].Matricule)
Ecrire ( Nom de lemploy :)
Lire (T[i].Nom)
Ecrire ( Salaire de lemploy :)
Lire (T[i].Sal)
Ecrire ( Etat civil de lemploy :)
Lire (T[i].Etat_Civil)
Fin pour
Fin
Fonction Compter (T : Tab) : Entier
Dbut
Compter 0
Pour i de 1 n faire
Si (T[i].Sal >=500) ET (T[i].Sal <=700) alors
Compter Compter + 1
Fin si
Fin pour
Fin
Dbut
Remplir (TabEmp)
Nb Compter (TabEmp)
Ecrire ( nb, employs touchent entre 500 et 700 Dt)
Fin





Chapitre 2 : Les pointeurs


Vue densemble
Cette leon prsente la dfinition et lutilisation des pointeurs.

Objectifs
Ce chapitre a pour objectifs de permettre aux tudiants dacqurir les connaissances de
base se rapportant aux objectifs spcifiques suivants:
Etre capable dutiliser les pointeurs.
grer un ensemble fini dlments dont le nombre varie au cours de lexcution du
programme.
Savoir crire un algorithme en utilisant des variables dynamiques laide du pointeur.

Pr-requis
Algorithmique 1
Les enregistrements

Dure
3 H

Elments de contenu
1. Rappel
2. Les variables dynamiques
3. Les pointeurs
4. Exercices dapplications
5. Solutions des exercices
Chapitre2 : Les Pointeurs



@quipe pdagogique Algorithmique2 10

2.1 Rappel
2.1.1 Mmoire centrale (MC)
La mmoire centrale mmorise les donnes en cours de traitement par lunit de traitement
(UT). Elle contient les instructions et les donnes du programme en cours. LUT lit une
instruction, les oprandes de cette instruction, calcule le rsultat puis lcrit dans la mmoire
centrale. En entre, lUT lit une donne depuis une unit dEntr\sortie et lcrit dans la MC
et inversement pour une sortie.
2.1.2 Structure de la mmoire centrale
La mmoire centrale est compose de cellules mmoire. Une cellule est un ensemble de 8
circuits lectroniques. Chaque circuit est capable de soutenir dans un de deux tats :

Haut reprsente le bit 1
Bas reprsente le bit 0
Une cellule est donc un ensemble de 8 bits dit un octet (8 bits = 1 octet). Les cellules de la
mmoire sont numrotes de 0 n-1, avec n est le nombre de cellules quelle contient.
Pour mmoriser plus dinformations, on utilise deux cellules adjacentes (un mot) ou 4 cellules
adjacentes (un double mot).
Une variable est en faite une petite zone mmoire issue de n octets que lon salloue et dans
laquelle les informations sont ranges.
2.1.3 La notion dadresse
Lors de la compilation dun programme, lordinateur rserve dans sa mmoire une zone
mmoire pour chaque variable dclare. Cest cet endroit que la valeur de la variable est
stocke. Il associe alors au nom de la variable ladresse de stockage. Ainsi, pendant le
droulement du programme, quand il rencontre un nom de variable, il va chercher ladresse
correspondante la valeur en mmoire.
En langage C, il est possible de mettre une valeur dans une variable laide de loprateur
= ou de la fonction scanf( ). Ladresse mmoire est accessible en faisant prcder la variable
de loprateur &.
Exemple :
char car = c;
printf ("adresse de car %lx", &car);

2.2 Les pointeurs
2.2.1 Dfinition
Un pointeur est une variable qui a pour valeur ladresse mmoire dune autre variable sur
laquelle il pointe. Le pointeur est dtermin par le type sur lequel il pointe (variable, premier
lment dun tableau, .).

Chapitre2 : Les Pointeurs



@quipe pdagogique Algorithmique2 11

2.2.2 Dclaration dun pointeur

En algorithmique, on dclare un pointeur en prcdant son type de base par le caractre ^ .
Syntaxe :

Nom_pointeur : ^ type

Exemple 1 :

P : ^caractre dclarer un pointeur appel P sur une variable de type caractre.



P P^

- La variable pointeur P a pour valeur ladresse 43 . Elle pointe sur lespace mmoire
P^ ladresse 43 dont le contenu est le caractre T .

- La dclaration dune variable de type pointeur a pour effet la rservation dune case
mmoire qui va contenir ladresse de la variable point.

Exemple 2 :

Si on dclare 2 pointeurs Pe et Pf
- Pe pointe vers une variable de type entier ;
-Pf pointe vers une variable de type rel,
Ceci implique la cration de deux variables qui contiennent respectivement ladresse
dun entier et ladresse dun rel comme suit :

Pe : ^entier
Pf : ^reel





2.2.3 Cration dun pointeur
Pour utiliser la variable point il faut dabord la crer, ce qui a pour effet de rserver un
bloc en mmoire capable de stocker la valeur de cette variable. Pour crer une variable point,
on utilise linstruction Allouer.


43
T
Mmoire
Pe
@?
Pf @?
Chapitre2 : Les Pointeurs



@quipe pdagogique Algorithmique2 12

Syntaxe :

Allouer (nom_pointeur)
Exemple :

Pour crer la variable point par Pe on crit : Allouer (Pe), et pour crer la variable point par
Pf on crit : Allouer (Pf).









- Linstruction Allouer (P) :
Rserve un bloc mmoire de la taille adquate pour contenir la valeur de la variable
pointe par P.
Rcupre ladresse de ce bloc et la met dans la variable P.

2.2.4 Utilisation dun pointeur
Pour accder la variable point par un pointeur appel P on utilise loprateur ^.
Syntaxe :

P^ : dsigne la variable pointe par P.
Exemple :
Lalgorithme suivant stocke la valeur 10 dans une variable de type pointeur.

Algorithme Pointeur_element
Var
P : ^entier
Debut
Allouer (P)
P^ 10
Fin



Mmoire
Pe
@1
Pf
@2
entier
rel
Mmoire
P
@ 10
Chapitre2 : Les Pointeurs



@quipe pdagogique Algorithmique2 13

2.2.5 Suppression dune variable point
Lorsquune variable pointe na plus dutilit, il est possible de la supprimer et de rendre
disponible lespace mmoire quelle occupe. Linstruction qui ralise cette tche est
Liberer .

Syntaxe :
Liberer (nom_pointeur)
Exemple :
Lexemple suivant montre leffet de linstruction Liberer sur la mmoire.

Algorithme exemple
Var
P : ^entier
Debut
Allouer (P)
P^ 10
Liberer (P)
P^ 4 {erreur}
Fin

- Liberer (P) supprime la variable point par P et libre lespace mmoire occup par
cette variable. Par contre la variable pointeur P nest pas supprime mais son contenu
nest plus ladresse de la variable point mais une adresse non significative.

Remarque :
- Lutilisation de la variable point aprs linstruction Liberer provoque une erreur.
2.2.6 Arithmtiques sur les pointeurs
2.2.6.1 Initialisation dun pointeur

Pour initialiser un pointeur on lui affecte une valeur constante appel Nil . Cette
constante signifie que le pointeur ne pointe sur rien.
Syntaxe :
P Nil



Mmoire

P
Mmoire
P
?
Chapitre2 : Les Pointeurs



@quipe pdagogique Algorithmique2 14

Exemple :
On peut aussi initialiser un pointeur partir dun autre pointeur comme le montre
lexemple suivant :
- Supposons quon soit dans la situation initiale illustre par la figure a :










Si linstruction : PQ est excut, nous passerons la nouvelle situation illustre par la
figure b.
Dans ce cas, on a : P^ = Q^ = Sousse
- Si on modifie la valeur de Q^, P^ sera galement modifi et restera gal Q^.









- Par contre, si linstruction : P^Q^ est excut. On passe la nouvelle situation illustre
par la figure c.













Sousse

Sousse
Q Q^
P^
P
P^
P

Tunis

Sousse
Q Q^
P

Tunis

Sousse
Q
Q^
P^
Chapitre2 : Les Pointeurs



@quipe pdagogique Algorithmique2 15

Dans ce cas, on a galement P^ = Q^ = Sousse ; Mais si lon modifie la valeur de Q^, P^
ne sera pas modifi.
2.2.6.2 Affectation dun pointeur un autre
Le contenu dune variable pointeur peut tre recopi dans une autre variable pointeur grce
linstruction daffectation, condition que les 2 pointeurs soit de mme type.
Exemple :
Les pointeurs P1 et P2 pointent sur un entier. Linstruction P1 P2 permet de copier
ladresse contenu dans P2 dans le pointeur P1. Donc P1 et P2 vont pointer vers la mme
variable.










2.2.6.3 Loprateur dadresse
Loprateur dadresse permet de rcuprer ladresse en mmoire dune variable il se note
&. Comme le pointeur contient ladresse dune variable pointeur on peut utiliser
loprateur dadresse pour affecter un pointeur ladresse dune autre variable et ainsi il va
pointer vers cette nouvelle variable. La syntaxe est la suivante : pointeur & variable
2.2.6.4 Comparaison de pointeurs
- On peut comparer 2 pointeurs entre eux avec loprateur = ou <> condition quils ont le
mme sous type. Et on peut comparer la valeur Nil nimporte quel pointeur quelque soit son
sous-type.
- On peut aussi comparer les valeurs des variables pointes par 2 pointeurs.

2.2.6.5 Exemple
Algorithme Adresse
Var
P : ^entier
A : entier
Debut
Mmoire
P1
@1 10
P2
@1
Chapitre2 : Les Pointeurs



@quipe pdagogique Algorithmique2 16

Allouer (P)
A 10
P & A
Ecrire (A) {10}
Ecrire (P^) {10}
Liberer (P)
Fin

2.2.6.6 Tableau rcapitulatif


Algorithmique Langage C
Syntaxe Exemple Syntaxe Exemple
Dclaration
pointeur
nomPointeur :^type P :^entier type* nomPointeur int * P ;
Cration
pointeur
Allouer (^type) Allouer(p) (type*)malloc(sizeof(type)) P=(int*)malloc(sizeof(int)) ;
Suppression
pointeur
Librer (^type) Librer(p) delete (type *) delete(p) ;

2.2.7 Les tableaux et les pointeurs
En dclarant un tableau, on dfinit automatiquement un pointeur (on dfinit en fait l'adresse
du premier lment du tableau).

Les tableaux une dimension:
Les critures suivantes sont quivalentes:

- En algorithmique :

tableau: ^entier int tableau[10]; dclaration

Allouer (tableau)

tableau^ tableau[0] le 1er lment

(tableau+i)^ tableau[i] un autre lment

Chapitre2 : Les Pointeurs



@quipe pdagogique Algorithmique2 17

tableau & tableau[0] adresse du 1er lment

( tableau + i) & (tableau[i]) adresse d'un autre lment

Les tableaux plusieurs dimensions:

Un tableau plusieurs dimensions est un pointeur de pointeur.

Exemple: int t[3][4]; t est un pointeur de 3 tableaux de 4 lments ou bien de 3 lignes 4
lments.

Les critures suivantes sont quivalentes:

t[0] &t[0][0] t :adresse du 1er lment

t[1] &t[1][0] adresse du 1er lment de la 2e ligne

t[i] &t[i][0] adresse du 1er lment de la ime ligne

t[i]+1 &(t[i][0])+1 adresse du 1er lment de la ime +1 ligne
Chapitre2 : Les Pointeurs



@quipe pdagogique Algorithmique2 18


REPARTITION DES ELEMENTS EN MEMOIRE
Le t ableau a t dclar ainsi: int t[3][4];
t[0]
t[0][0]
t[0][2]
t[1]
t[2]
t[2][3]



2.2.8 Les chaines des caractres et les pointeurs
Les chanes de caractres sont des tableaux de caractres. Leur manipulation est donc
analogue celle d'un tableau une dimension:

2.3 Exercices dapplication
Exercice 1
Complter le tableau en indiquant les valeurs des diffrentes variables au terme de chaque
instruction du programme suivant (on peut aussi indiquer sur quoi pointent les pointeurs) :
Programme A B C P1 P1^ P2 P2^
A, B, C : entier
P1, P2 :^entier ;

- - - - - - -
A 1, B 2, C 3


P1 &A, P2 &C


P1^ (P2^) ++


P1 P2


P2 &B


P1^ - P2^


Chapitre2 : Les Pointeurs



@quipe pdagogique Algorithmique2 19

P2^= (P2^ )++


P1^ * P2^


A = ++ P2^ * P1^ ;


P1 = &A ;


P2^ = P1^ /= ^P2 ;



Exercice 2
Soit P un pointeur qui pointe sur un tableau A dont ses valeurs sont {12 , 23,
34 ,45,56,67, 78, 89, 90}
P : ^entier
P=A ;
Quelle valeur fournissent ces expressions :
a) P^+2
b) (p+2)^
c) P+1
d) & A [4] +1
e) A+3
f) P + (P^ - 10)
g) (P + (P+9)^ -A [8])^
Exercice 3
On dclare un tableau de 10 entiers A. Ecrire un algorithme et un programme permettant de
remplir et dafficher ce tableau.
Dclarer un pointeur pointant vers l'lment 7 de A. Incrmenter le pointeur c'est--dire le
faire pointer vers la case suivante. Incrmenter la valeur pointe. Vrifier par laffichage des
rsultats.
Afficher le tableau aprs modifications.


Chapitre2 : Les Pointeurs



@quipe pdagogique Algorithmique2 20

Exercice 4
Ecrire, de deux faons diffrentes, un algorithme et un programme en C qui lit 10 nombres
entiers dans un tableau avant den rechercher le plus grand et le plus petit :
1. en utilisant uniquement le formalisme tableau,
2. en utilisant le formalisme pointeur chaque fois que cela est possible.
2.4 Solutions des exercices
Exercice 1
Programme A B C P1 P1^ P2 P2^
A, B, C : entier
P1, P2 :^entier ;

- - - - - - -
A 1, B 2, C 3

1 2 3 - - - -
P1 &A, P2 &C

1 2 3 &A 1 &C 3
P1^ (P2^) ++

3 2 4 &A 3 &C 4
P1 P2

3 2 4 &C 4 &C 2
P2 &B

3 2 4 &C 4 &B 2
P1^ - P2^

3 2 2 &C 2 &B 2
P2^= (P2^ )++

3 3 2 &C 2 &B 3
P1^ * P2^

3 3 6 &C 6 &B 3
A = ++ P2^ * P1^ ;

24 4 6 &C 6 &B 4
P1 = &A ;

24 4 6 &A 24 &B 4
P2^ = P1^ /= ^P2 ;

6 6 6 &A 6 &B 6
Exercice 2
a) P^+2 : 14
b) (p+2)^ : 23
c) P+1 : &A [2]
d) & A [4] +1 : &A [5]
e) A+3 : &A [4]
Chapitre2 : Les Pointeurs



@quipe pdagogique Algorithmique2 21

f) P + (P^ - 10) : &A [3]
g) (P + (P+9)^ -A [8])^ : 23
Exercice 3
Algorithme Pointeur_tableau
Variables
A : tableau [1..10] de entier
i : entier
c :^entier
Dbut
Allouer(c)
Pour i de 1 10 faire
Ecrire ( donner les lments du tableau )
Lire (A[i])
Fin pour
Pour i de 1 10 faire
Ecrire (A[i])
Fin pour
c&A[7]
cA[7+1]
c^ c^ +1
ecrire ( ladesse et le contenu de c sont respectivemnt2 , c, c^).
Pour i de 1 10 faire
Ecrire (A[i])
Fin pour
Liberer(c)
Fin




Chapitre2 : Les Pointeurs



@quipe pdagogique Algorithmique2 22


Exercice4 :
a/
Algorithme min_max
Const NVAL =10
Var
i,min,max,min_p,max_p :entier
t : tableau [1..NVAL] de entier
t :^entier
Dbut
Pour i de 1 NVAL faire
Lire(t[i])
Fin pour
ecrire( formalisme tableau )
max=min=t[0]
pour i de1 NVAL faire
si (t[i]>max) alors
maxt[i]
si (t[i]<min) alors
mint[i]
finsi
ecrire( val max ,max)
ecrire( val min ,min)
ecrire ( formalisme pointeur )
Allouer(t)
max_p=min_p=t
pour i de 1 NVAL faire
si ((t+i)^ > max_p) alors
max_p=(t+i)^
si ((t+i)^ < min_p) alors
min_p=(t+i)^
Chapitre2 : Les Pointeurs



@quipe pdagogique Algorithmique2 23

finsi
ecrire( val_max , max_p)
ecrire( val_min , min_p)
liberer(t)
Fin
b/
Algorithme min_max
Const NVAL =10
Var
i,min,max,min_p,max_p :entier
t : tableau [1..NVAL] de entier
t :^entier
Dbut
Pour i de 1 NVAL faire
Lire(t[i])
Fin pour
ecrire( formalisme tableau )
max=min=t[0]
pour i de1 NVAL faire
si (t[i]>max) alors
maxt[i]
si (t[i]<min) alors
mint[i]
finsi
ecrire( val max ,max)
ecrire( val min ,min)
ecrire ( formalisme pointeur )
Allouer(t)
max_p=min_p=t
pour i de 1 NVAL faire
si ((t+i)^ > max_p) alors
Chapitre2 : Les Pointeurs



@quipe pdagogique Algorithmique2 24

max_p=(t+i)^
si ((t+i)^ < min_p) alors
min_p=(t+i)^
finsi
ecrire( val_max , max_p)
ecrire( val_min , min_p)
liberer(t)
Fin






Chapitre 3 : Les listes


Vue densemble
Ce Chapitre prsente la dfinition et lutilisation des listes

Objectifs
Ce chapitre a pour objectifs de permettre aux tudiants dacqurir les connaissances de
base se rapportant aux objectifs spcifiques suivants:
Etre capable dutiliser les listes.
Connatre une nouvelle structure de donnes, sa cration et surtout les oprations de
base sur une liste chane
Savoir crire un algorithme en utilisant la structure de donnes listes.

Pr-requis
Algorithmique 1
Les enregistrements
Les pointeurs

Dure
3 H

Elments de contenu
1. Introduction
2. Dfinition
3. Oprations sur les listes
4. Reprsentations
5. Algorithmes de quelques oprations sur les listes
Chapitre3 : Les Listes



@quipe pdagogique Algorithmique2 27


3.1 Introduction
Le principal problme des donnes stockes sous forme de tableaux est que celles-ci
doivent tre ordonnes : le "suivant" doit toujours tre stock physiquement derrire.
Imaginons grer une association. Un tableau correspond une gestion dans un cahier : un
adhrent par page. Supposons dsirer stocker les adhrents par ordre alphabtique. Si un
nouvel adhrent se prsente, il va falloir trouver o l'insrer, gommer toutes les pages
suivantes pour les rcrire une page plus loin, puis insrer le nouvel adhrent. Une solution un
peu plus simple serait de numroter les pages, entrer les adhrents dans n'importe quel ordre
et disposer d'un index : une feuille o sont indiqus les noms, dans l'ordre, associs leur
"adresse" : le numro de page. Toute insertion ne ncessitera de dcalages que dans l'index.
Cette mthode permet l'utilisation de plusieurs index (par exemple un second par date de
naissance). La troisime solution est la liste chane : les pages sont numrotes, sur chaque
page est indique la page de l'adhrent suivant, sur le revers de couverture on indique l'adresse
du premier. Ainsi, l'insertion d'un nouvel adhrent se fera avec le minimum d'oprations.
Nous intressons dans ce chapitre de cette nouvelle structure de donnes, sa cration et surtout
les oprations de base sur une liste chane.
3.2 Dfinition
Les listes font parties des structures de donnes abstraites trs couramment utilises dans
les programmes. Une structure de donne abstraite est un type de donne dfini par
lutilisateur sous forme de deux composantes une pour reprsenter les donnes (les notations)
et une pour reprsenter les oprations daccs aux donnes et ses caractristiques.
Une liste stocke un ensemble de donnes et permet de parcourir cet ensemble du dbut
la fin dans l'ordre. Cest une suite finie (ventuellement vide) d'lments, Lorsque elle nest
pas vide, son premier lment est appel tte et la suite constitue des autres lments est
appele queue.
Remarque : Les listes servent pour reprsenter des structures de donnes dont la taille change
souvent ou pour stocker des donnes dans l'ordre en ayant la possibilit de les mettre jour
quand il y a des changements.
3.3 Oprations sur les listes
Il existe un certain nombre d'oprations classiques sur les listes.
Le test si la liste est vide.
ajouter un lment:
o au dbut de la liste
o la fin de la liste
o un rang donn
Chapitre3 : Les Listes



@quipe pdagogique Algorithmique2 28


rechercher un lment:
o rsultat boolen
o rsultat = rang de la premire occurrence
o rsultat = nombre d'occurrences
enlever un lment:
o caractris par sa valeur
o caractris par son rang
calculer la longueur d'une liste (nombre d'lments)
3.4 Reprsentation
3.4.1 Reprsentation graphique



3.4.2 Reprsentation des donnes
La structure de donne qui permet de reprsenter une liste chane dans le cas gnral est
dclare comme suit :
Type
Cellule = enreg
valeur : type
suivant : ^Cellule
FinEnreg
Liste : ^Cellule
Ainsi le type Liste est un pointeur vers le type Cellule qui est un enregistrement form de
deux champs : un qui contient la valeur de llment donc le type peut tre un type
quelconque et le 2
me
champ contient un pointeur vers la cellule suivante. C'est--dire il
contient ladresse de la cellule suivante. La dernire cellule ne pointe vers rien donc elle doit
contenir la valeur Nil.
L
Chapitre3 : Les Listes



@quipe pdagogique Algorithmique2 29


Le type Liste contient un pointeur vers le type Cellule qui contient ladresse du 1
er
lment de
la liste.
3.5 Algorithmes de quelques oprations sur les listes
Pour simplifier on va travailler sur une liste dont les valeurs sont de type entier. Alors la
dfinition du type liste sera comme suit :
Type
Cellule = enreg
valeur : entier
suivant : ^Cellule
FinEnreg
Liste : ^Cellule
ListeVide :
La 1
re
fonction de base quon doit crire pour pouvoir manipuler des donnes de type liste est
la fonction ListeVide () qui prend en entre une liste et retourne vrai si elle est vide et faux
sinon.
Fonction ListeVide (liste1 : Liste) : Booleen
Debut
Si (liste1 = Nil) Alors
Retourner (Vrai)
Sinon
Retourner (Faux)
FinSi
Fin

PosFin :
La fonction PosFin () prend en entre une liste et retourne un pointeur vers le dernire
lment de la liste.




Chapitre3 : Les Listes



@quipe pdagogique Algorithmique2 30


Fonction PosFin (liste1 : Liste) : Liste
Var listeAux : Liste
Debut
listeAux liste1
Si (listeAux <> Nil) Alors
Tantque (listeAux^.suivant <> Nil) Faire
listeAux listeAux^.suivant
Fintanque
FinSi
Retourner (listeAux)
Fin

AjouterTete :
La fonction AjouterTete () prend en entre une valeur ajouter en tte dune liste donne et
retourne un pointeur vers le dbut de la nouvelle liste.
Cette fonction doit crer une nouvelle variable dynamique pour contenir la nouvelle cellule,
puis remplir le champ valeur et le champ suivant de cette cellule ensuite mettre ladresse de
cette cellule dans le pointeur vers la tte de liste et retourner cette valeur.

Fonction AjouterTete (v : entier, L : Liste) : Liste
Var C : ^Cellule
Debut
Allouer (C)
C^.valeur v
C^.suivant L
L C
Retourner (L)
Fin


Ajouter un lment la fin de la liste
La fonction Ajouter_fin() prend en entre une valeur ajouter la fin dune liste donne et
retourne un pointeur vers le dbut de la nouvelle liste.
v
L
Chapitre3 : Les Listes



@quipe pdagogique Algorithmique2 31



procedure ajouter_fin(liste1 : Liste, e : entier)
liste2 : Liste;
debut
oSi (liste1= Nil) Alors liste1 new couple(e, null)
sinon
/* parcours de la liste vers la fin */
Liste2 PosFin(liste1)
/*ajout de llment e la fin de la liste */
liste2.suivant new couple(e, null)
fisi /* nous pouvons ajouter le retour en tte de la liste */
fin ajouter_fin;

langueur dune Liste
Cette fonction calcule le nombre des lments de la liste. Elle prend comme argument
lentre une liste et retourne comme sortie un entier prsentant la langueur de la liste.
function longueur(liste1 : Liste) : entier
x : entier
listeAux : Liste
dbut
x 0
listeAux liste1
Tantque (listeAux^.suivant <> Nil) Faire
x x + 1
listeAux listeAux^.suivant
Fintanque
retourner x;
fin longueur

chercher un lment dans la liste
Chapitre3 : Les Listes



@quipe pdagogique Algorithmique2 32


Cette fonction permet de rechercher la position dun lment dans une liste en supposant
quil existe, sinon, la fonction retourne faux. Ses paramtres dentre sont alors la liste et
llment recherch, et son paramtre de sortie tant un boolen.

function appartient(x : entier; liste1 : Liste) : boolen
liste2 : Liste
dbut
liste2 liste1
tantque (liste2 != null && liste2^.valeur <>x)
liste2 liste2^.suivant
fin tantque
si (liste2^.valeur <>x) alors
retourner (vrai)
sinon
retourner (faux)
fin si
fin appartient;



Chapitre 4 : Les Piles et les
Files

Vue densemble
Ce Chapitre prsente la dfinition et lutilisation des Piles et des files

Objectifs
Ce chapitre a pour objectifs de permettre aux tudiants dacqurir les connaissances de
base se rapportant aux objectifs spcifiques suivants:
Etre capable dutiliser les piles et les files.
Connatre une nouvelle structure de donnes, sa cration et surtout les oprations de
base sur une pile et une file
Savoir crire un algorithme en utilisant les structure de donnes piles et files.

Pr-requis
Algorithmique 1
Les enregistrements
Les pointeurs

Dure
6 H

Elments de contenu
1. Introduction
2. Les piles
3. Les files

Chapitre4 : Les Piles et les Files


@quipe pdagogique Algorithmique2 33


4.1 Les piles
4.1.1 Prsentation
Une pile est une suite de cellules alloues dynamiquement (liste chane) o linsertion et
la suppression dun lment se font toujours en tte de liste.
Limage intuitive dune pile peut tre donne par une pile dassiettes, ou une pile de
dossiers condition de supposer quon prend un seul lment la fois (celui du sommet). On
peut rsumer les contraintes daccs par le principe dernier arriv, premier sorti qui se
traduit en anglais par : Last In First Out (figure 1).

La structuration dun objet en pile simpose lorsquon mmorise des informations qui
devront tre traites dans lordre inverse de leur arrive. Cest le cas, par exemple, de la
gestion des adresses de retour dans lexcution dun programme rcursif.
En supposant que les lments de la pile sont des entiers, celle-ci se dclare de la faon
suivante :
Types
Pile = ^Cellule
Cellule = Enreg
Elem : Entier
Suiv : Pile
FinEnreg
Var
P : Pile
E1 E2 E3 Nil
Sommet
Chapitre4 : Les Piles et les Files


@quipe pdagogique Algorithmique2 34


4.1.2 Manipulation dune pile
Dun point de vue manipulation, les contraintes daccs sont matrialises par les
procdures et les fonctions suivantes :
Procdure Initialiser (Var P : Pile) : cre une pile vide P.
Procdure Initialiser (Var P : Pile)
Dbut
P Nil
Fin
Fonction Pile_Vide (P : Pile) : Boolen : renvoie la valeur vrai si la pile est vide.
Fonction Pile_Vide (P : Pile) : Boolen
Dbut
Pile_Vide (P = Nil)
Fin
Procdure Empiler (x : Entier ; Var P : Pile) : ajoute llment x au sommet de la
pile.
Procdure Empiler (x : Entier ; Var P : Pile)
Variables
Q : Pile
Dbut
Allouer (Q)
Q^.Elem x
Q^.Suiv P
P Q
Fin



x
P
Chapitre4 : Les Piles et les Files


@quipe pdagogique Algorithmique2 35

Procdure Dpiler (Var x : Entier ; Var P : Pile) : dpile le sommet de la pile et le
met dans la variable x.
Procdure Dpiler (Var x : Entier ; Var P : Pile)
Dbut
Si NON (Pile_Vide(P)) Alors
x P^ .Elem
Q P
P P^ .Suiv
Librer (Q)
Sinon
Ecrire (Impossible, la pile est vide)
FinSi
Fin

4.2 Les Files
4.2.1 Prsentation
Une file est une suite de cellules alloues dynamiquement (liste chane) dont les contraintes
daccs sont dfinies comme suit :
- On ne peut ajouter un lment quen dernier rang de la suite.
- On ne peut supprimer que le premier lment.
Limage intuitive dune file peut tre donne par la queue devant un guichet lorsquil ny a
pas de resquilleurs. On peut rsumer les contraintes daccs par le principe premier arriv,
premier sorti qui se traduit en anglais par : First In First Out.

La structuration dun objet en file simpose en particulier lorsquune ressource doit tre
partage par plusieurs utilisateurs : il y a formation dune file dattente.
Queue
E1 E2 E3 Nil
Sommet

P
Chapitre4 : Les Piles et les Files


@quipe pdagogique Algorithmique2 36

Un exemple est donn par le spooler dimpression qui est un programme qui reoit, traite,
planifie et distribue les documents imprimer dans un systme multiprogramm.
En supposant que les lments de la file sont des entiers, celle-ci se dclare de la faon
suivante :
Types
Liste = ^Cellule
Cellule = Enreg
Elem :Entier
Suiv : Liste
FinEnreg
File = Enreg
Tte : Liste
Queue : Liste
FinEnreg
Var
F : File
4.2.2 Manipulation dune file
Dun point de vue manipulation, les contraintes daccs sont matrialises par les procdures
et les fonctions suivantes :
Procdure Initialiser (Var F : File) : cre une file vide F.
Procdure Initialiser (Var F : File)
Dbut
F.Tte Nil
F .Queue Nil
Fin
Procdure Ajouter (x : Entier ; Var F : File) : ajoute llment x la fin de la file.
Procdure Ajouter (x : Entier ; Var F : File)
Var
P : Liste
Dbut
Chapitre4 : Les Piles et les Files


@quipe pdagogique Algorithmique2 37

Allouer (P)
P^ .Elem x
P^ .Suiv Nil
Si (F .Queue <> Nil) Alors
F .Queue^. Suiv P
Sinon
F.Tte P
FinSi
F .Queue P
Fin
Dans le cas o la file est vide, comme la queue, la tte de la file doit galement pointer vers
le nouvel lment.
Procdure Extraire (Var x : entier ; Var F : File) : extrait le sommet de la file et le
met dans la variable x.
Procdure Extraire (Var x : entier ; Var F : File)
Var
P : Liste
Dbut
Si (F.Tte = Nil) Alors
Ecrire ( impossible, la file est vide )
Sinon
P F.Tte
x F.Tte^.Elem
F.Tte F.Tte^. Suiv
Librer (P)
FinSi
Fin
Remarque
Dans les langages qui noffrent pas le type pointeur, les structures de pile ou file peuvent tre
implantes sous forme de tableaux.
Ainsi, une pile dentiers peut tre dclare de la faon suivante :
Chapitre4 : Les Piles et les Files


@quipe pdagogique Algorithmique2 38

Constantes
n = 100
Types
Indice : 1..n
Cellule = Enreg
Elem : entier
Suiv : Indice
FinEnreg
Pile = Tableau [Indice] de cellule
Variables
L : Pile



Chapitre 5 : La Rcursivit


Vue densemble
Cette leon prsente la dfinition et lutilit de la rcursivit.

Objectifs
Ce chapitre a pour objectifs de permettre aux tudiants dacqurir les connaissances de
base se rapportant aux objectifs spcifiques suivants:
Etre capable de transformer un schma itratif simple en un schma rcursif.
Savoir crire un algorithme rcursif.

Pr-requis
Algorithmique 1

Dure
6 H

Elments de contenu
1. Rappel
2. Algorithmes rcursives
Chapitre5 : La rcursivit


@quipe pdagogique Algorithmique2 39


5.1 Rappel
5.1.1 Les procdures
5.1.1.1 Dfinition
Une procdure est un sous algorithme ralisant un traitement sur une partie des donnes
dun algorithme principal. Elle permet de dcomposer un algorithme en sous algorithme ou
module plus simple et donc de simplifier la lecture et le suivi dun algorithme. Une procdure
est dfinie avant le code de lalgorithme principal puis elle est appele par son nom suivi de
ses paramtres sils existent.
Syntaxe


Procedure nom (P1: type, , Pn : type)
Var
{Variable}
Debut
<Traitement>
Fin

Algorithme Principal
Var
{Variable}
Debut

nom (P1, , Pn)

Fin

Remarque :
- nom est le nom de la procdure.
- type est un type de donne simple ou compos.
- P1 Pn sont les paramtres de la procdure.
- Une procdure peut tre appele partir de lalgorithme principal ou dune autre procdure.

Schma dexcution
Lappel de la procdure se fait en utilisant son nom suivi de ses paramtres spars par des
virgules et entours par des parenthses. Quand on appelle une procdure le contrle se trouve
automatiquement transfr au dbut de la procdure. Quand toutes les instructions de la
procdure ont t excutes le contrle retourne linstruction qui suit immdiatement
linstruction dappel de la procdure.







Chapitre5 : La rcursivit


@quipe pdagogique Algorithmique2 40



Algorithme Principal
Var
V1: entier
Debut



proc (V1)



Fin
Procedure proc (P1: entier)
Var
X1 : reel
Debut






Fin
5.1.1.2 Les variables et les paramtres
Variable locale
Une variable est dite locale si elle est dfinie dans la partie de dclaration des variables
propre la procdure. Elle nest accessible que dans la procdure o elle a t dfinie. Dans
lexemple prcdent X1 est une variable locale la procdure proc.
Variable globale
Une variable est dite globale si elle est dfinie au niveau de lalgorithme principal qui
appelle la procdure cest dire une variable utilise par la procdure et qui nest pas dclar
dans cette procdure. Une variable globale peut tre utilis nimporte o, lintrieur ou
lextrieur dune procdure on parle donc de visibilit et on dit quelle est visible par
lalgorithme principal et par toutes les autres procdures utilises. Dans lexemple prcdent
V1 est une variable globale.
Lchange dinformation entre la procdure et lalgorithme peut se faire travers les
variables globales. Cette mthode peut changer le contenu de la variable lintrieur de la
procdure ce qui peut affecter lexcution de lalgorithme principal. Pour rsoudre ce
problme on fait recours lemploie des paramtres qui offrent une meilleur approche pour
lchange dinformation entre la procdure et le lalgorithme principal. Le transfert dune
donne se fait entre un paramtre effectif et un paramtre formel.
Paramtre formel
Un paramtre formel est un paramtre dfini dans la dclaration de la procdure c'est--
dire dans lentte de procdure. Dans lexemple prcdent P1 est un paramtre formel la
procdure proc.
Chapitre5 : La rcursivit


@quipe pdagogique Algorithmique2 41

Paramtre effectif
Un paramtre effectif est un paramtre utilis pendant lappel de la procdure. Dans
lexemple prcdent V1 est un paramtre effectif pour la procdure proc. Lors de lappel de la
procdure et avant de commencer son excution les paramtres formels sont initialiss par les
valeurs des paramtres effectifs. Ainsi dans lexemple prcdent P1 est initialis avec la
valeur de V1.
Exemple

Procedure max (x : entier, y : entier)
Var
m : entier
Debut
Si x>y Alors
m x
Sinon
m y
FinSi
Ecrire ("le max est :", m)
Fin
Algorithme Maximum
Var
A, B : entier
Debut
Lire (A, B)
max (A, B)
Fin

On dsigne par
- A, B: 2 paramtres effectifs
- x, y: 2 paramtre formels
- A, B : variables globales
- m: variable locale
5.1.1.3 Passage des paramtres
Passage des paramtres par valeur
Le mode de transfert de paramtre entre lalgorithme appelant et la procdure appel
dfinit un moyen dchange de donne entre eux. Dans le passage des paramtres par valeur
qui reprsente le 1
er
mode, les paramtres formels de la procdure reoivent les valeurs des
paramtres effectifs, ainsi avant lexcution de la procdure, ses paramtres formels sont
initialiss avec les valeurs des paramtres effectifs. Tous changement des paramtres formels
dans la procdure ne change pas les valeurs des paramtres effectifs associs. Dans lexemple
prcdent le mode de passage des paramtres pour la procdure max est par valeur, les
paramtres formels sont x et y, ils sont initialiss par les valeurs de A et B.
Passage des paramtres par variable
Contrairement au mode de passage des paramtres par valeur, dans le mode de passage des
paramtres par variable toutes modification dans la valeur du paramtre formel pass par
variable, implique une modification de la valeur du paramtre effectif correspondant. Ainsi ce
Chapitre5 : La rcursivit


@quipe pdagogique Algorithmique2 42

2
me
mode est plus gnral que le 1
er
il prend les caractristiques du 1
er
et ajoute la possibilit
de modifier les variables de lalgorithme appelant partir de la procdure.
Pour dfinir un passage de paramtre par variable on ajoute le mot cl var dans la
dfinition des paramtres de la procdure avant les paramtres pour lesquels on veut dfinir ce
mode.
Un paramtre pass par variable ne peut tre quune variable il ne peut pas tre une
constante ou une expression.
Exemple
Procedure max (x : entier, var y : entier)
Var
m : entier
Debut
Si x>y Alors
m x
Sinon
m y
FinSi
Ecrire ("le max est :", m)
x 0
y 0
Fin
Algorithme Maximum
Var
A, B : entier
Debut
Lire (A, B) {2,4} {ceci est un
commentaire}
max (A, B)
Ecrire (A, B)
Ecrire (x, y)
Fin

5.1.2 Les fonctions
5.1.2.1 Dfinition
La fonction possde la mme dfinition que la procdure mais avec seulement 2
diffrences. Dabord une fonction possde une valeur de retour. Ensuite la fonction est utilise
dans lalgorithme principal comme une variable contrairement la procdure qui est utilis
comme une instruction.
Syntaxe

Fonction nom_fonction (P1: type, , Pn :
type) : type
Var
{Variable}
Debut
<Traitement>
Retourner (val_retour)
Fin

Algorithme Principal
Var
vf : type

Debut

vf nom_fonction (P1, , Pn)

Fin
Chapitre5 : La rcursivit


@quipe pdagogique Algorithmique2 43


Remarque : Le type de la fonction doit tre le mme que le type de la variable vf utilis dans
lalgorithme principal pour recevoir la valeur de retour de la fonction.
Exemple
Fonction max (x : entier, y : entier) : entier
Var

Debut
Si x>y Alors
Retourner (x)
Sinon
Retourner (y)
FinSi
Fin
Algorithme Maximum
Var
A, B, M : entier
Debut
Lire (A, B) {2,4}
M max (A, B)
Ecrire ("le max est :", M)
Fin

5.2 Algorithmes rcursifs
5.2.1 Dfinitions rcursives
Une dfinition rcursive est dfinie en fonction d'un objet ou d'une action de mme nature
mais de complexit moindre.
Exemple
On peut dfinir le factoriel d'un nombre n positif de deux manires:
- dfinition non rcursive (ou itrative):
n ! = n * n-1 * ... 2 * 1
- dfinition rcursive:

n ! = n * (n-1) !
et 0 ! = 1

Une dfinition rcursive est compose de deux partie: une partie strictement rcursive et
une partie non rcursive (base) servant de point de dpart l'utilisation de la dfinition
rcursive.
Chapitre5 : La rcursivit


@quipe pdagogique Algorithmique2 44

5.2.2 Fonctions rcursives
5.2.2.1 Dfinition
Comme pour les dfinitions rcursives, les fonctions rcursives sont des fonctions qui sont
appeles depuis leur propre corps de fonction, soit directement soit indirectement, travers
une ou plusieurs fonctions relais. Si la fonction P appelle directement P, on dit que la
rcursivit est directe. Si P appelle une fonction P1, qui appelle une fonction P2 et qui enfin
appelle P, on dit qu'il s'agit d'une rcursivit indirecte.
Si la fonction P appelle dans son propre corps la fonction P, il est logique de penser que
lexcution ne s'arrtera jamais. Il est donc primordial qu'une des branches de la fonction P
permette de stopper la rcursivit.
Exemple
On veut calculer la somme des n premiers entiers positifs. Une dfinition rcursive de cette
somme serait:
Somme (n) = n + somme (n-1)
Et somme(1) = 1

Ce qui se traduit par la fonction rcursive suivante:

Fonction somme (n : entier) : entier
Var
m : entier
Debut
Si (n = 1) alors
somme 1
Sinon
m somme (n-1)
somme n + m
FinSi
Fin

Il est clair que sans le test Si (n = 1) cette fonction ne s'arrterait jamais.
5.2.2.2 Excution dune fonction rcursive
Supposant qu'on appelle la fonction somme (4). Puisque 4 1, cette fonction va s'appeler
elle-mme avec la valeur 3 (somme (3)). Ce nouvel appel se termine en renvoyant une valeur
Chapitre5 : La rcursivit


@quipe pdagogique Algorithmique2 45

(dans cet exemple la valeur retourne est 6 = 3 + 2 + 1). Cette valeur sera ajoute la valeur 4
et l'appel de somme (4) retournera la valeur 10 (4 + 6).
L'appel somme (3) suivra le mme processus et appellera somme (2) qui lui-mme appellera
somme (1) qui retourne 1.
somme(4)
somme(3)
somme(2)
somme(1)
retourne 1
retourne 2 + 1
retourne 3 + 3
retourne 4 + 6
5.2.2.3 Variables locales et paramtres des fonctions rcursives
Lorsqu'une fonction rcursive dfinit des variables locales, un exemplaire de chacune
d'entre elles est cr chaque appel rcursif de la fonction.
Dans notre exemple somme (4), la variable locale m est cre 4 fois. Ces variables sont
dtruites au fur et mesure que l'on quitte la fonction comme toute variable locale d'une
fonction.
Il en est de mme des paramtres des fonctions.
somme(4)
cration du 1
er
m
somme(3)
cration du 2
me
m
somme(2)
cration du 3
me
m
somme(1)
cration du 4
me
m
destruction de m
retourne 1
destruction de m
retourne 2 + 1
destruction de m
retourne 3 + 3
destruction de m
retourne 4 + 6
Chapitre5 : La rcursivit


@quipe pdagogique Algorithmique2 46

5.3 Exercices dapplication

Exercice 1 :
Ecrire une fonction rcursive qui permet de calculer le produit de deux entiers k et x selon la
formule suivante : K*x=x+ (k-1)*x
On prendra soin de trouver les cas particuliers (pour que la rcursivit sarrte)
Exercice2:
Pour calculer le PGCD de deux entiers positifs a et b, nous allons utiliser lalgorithme
dEuclide.
Celui-ci est rsum comme suit :
Si lun des entiers est nul, alors le PGCD est gal lautre.
Sinon le PGCD de a et b est gale au PGCD de a et de b-a (sous lhypothse que b>=a)
Ecrire la fonction rcursive correspondante.
Exercice 3 :
1. Nous cherchons raliser une fonction qui partir de deux entiers positifs a et b, renvoie
le quotient de la division de a par b .On cherche raliser cela sans utiliser les oprateurs DIV
ou MOD,
Ecrire le programme de cette division sous forme rcursive.
2. Mme question, mais pour le reste de la division de a par b
Exercice 4 :
Ecrire une fonction rcursive qui prend en entre un entier positif N et retourne la valeur de
N factoriel (N !), en utilisant la dfinition rcursive suivante :
N ! = N * (N-1) !
0 ! = 1
Exercice 5 :
Ecrire une fonction rcursive qui permet de calculer les n termes de la suite de Fibonacci
sachant que :
F (0) = 1
F (1) = 1
Pour tout N 2 : F (N) = F (N-1) + F (N-2)



Chapitre5 : La rcursivit


@quipe pdagogique Algorithmique2 47

Exercice 6 :
On dsire raliser les tches suivantes :
1- Saisir un entier N (0 <N <20).
2- remplir un tableau T par N entiers positifs.
3- Inverser le tableau T.
4- Afficher le nouveau tableau T.
Exemple :
Si on donne N=7 et T
1 10 9 6 11 3 8
Aprs inversion on obtient
8 3 11 6 9 10 1
Ecrire le programme principal et les sous programmes ncessaires pour raliser ces
tches.
Les algorithmes de la tche 1,2 et 4 doivent tre itratifs et celui de la tache 3 rcursif.

5.4 Solutions des exercices

Exercice1 :
Fonction produit(k :entier,x :entier) :entier
var
p :entier
debut
Si (k=1) alors
Px
sinon
si(k=0) alors
p0
sinon
px+produit(k-1,x)
FinSi
FinSi
returner(p)
Fin

Chapitre5 : La rcursivit


@quipe pdagogique Algorithmique2 48

Exercice 2
Foncion pgcd(a :entier,b :entier) :entier
var
r :entier
debut
Si ((a=0) ou (b=0))alors
Ra+b;
sinon

Si (b>=a) alors
Rpgcd(a,b-a);
sinon
rpgcd(b,a-b);
FinSi

FinSi
returner(r)
Fin


Exercice 3
Fonction quotient(a :entier,b :entier) :entier
var
q :entier
debut
si (a<b) alors
q0;
sinon
q1+quotient(a-b,b);
finSi
returner(q)
Fin
Fonction reste(a :entier,b :entier) :entier
var
r :entier
Chapitre5 : La rcursivit


@quipe pdagogique Algorithmique2 49

debut
si (a<b)alors
ra;
sinon
rreste(a-b,b)
finSi
returner(r)
Fin


Exercice 4

Fonction Factoriel(n :entier):entier

var
F: entier
Debut
Si(n=0) Alors
Retourner(1)
Sinon
F Factoriel(n-1)
Retourner(n*F)
FinSi
Fin


Exercice 5
Fonction Fibonacci(n :entier):entier
var
F1,F2: entier
Debut
Si(n=0 ou n=1) Alors
Retourner(1)
Sinon
F1 Fibonacci(n-1)
Chapitre5 : La rcursivit


@quipe pdagogique Algorithmique2 50

F2 Fibonacci(n-2)
Retourner(F1+F2)
FinSi
Fin

Exercice 6
Procedure saisir(var n:entier)

debut
ecrire("taper un entier entre 1..20")
lire(n)

Si (n>20) ou (n<0)
alors saisir(n)
fin

procedure remplir(var a: tableau[1..20] de entier;n:entier)
var i:entier

debut

lire(a[n])

Si a[n]<0 Alors
remplir(a,n)
sinon si n>1 alors
remplir(a,n-1)
finSi
fin

procedure affiche(a: tableau[1..20] de entier;n:entier)
var i:entier

debut

ecrire(a[n])

Si n>1 Alors
affiche(a,n-1)
Chapitre5 : La rcursivit


@quipe pdagogique Algorithmique2 51

finSi
fin

procedure inverser(var t: tableau[1..20] de entier;d,f:entier)
var aux:entier

debut
Si d <f alors
auxt[d]
t[d]t[f]
t[f]aux
inverser(t,d+1,f-1)
FinSi
Fin

//Algorithme principlal
Algorithme inversttrecursif
var
t: tableau[1..20] de entier
n:entier
debut

saisir(n)
remplir(t,n)
affiche(t,n)
inverser(t,1,n)
affiche(t,n)
Fin





Chapitre 6 : Les arbres et les
graphes

Vue densemble
Ce Chapitre prsente la dfinition et lutilisation des arbres et des graphes

Objectifs
Ce chapitre a pour objectifs de permettre aux tudiants dacqurir les connaissances de
base se rapportant aux objectifs spcifiques suivants:
Etre capable dutiliser les arbres et les graphes.
Connatre une nouvelle structure de donnes, sa cration et surtout les oprations de
base sur un arbre et un graphe
Savoir crire un algorithme en utilisant se rapportant des structures dynamiques de
donnes arbres et graphes.

Pr-requis
Algorithmique 1
Les enregistrements
Les pointeurs
La rcursivit

Dure
6 H

Elments de contenu
1. Les arbres
2. Les graphes
Chapitre6 : Les arbres et les graphes


@quipe pdagogique Algorithmique2 52


6.1 Les Arbres
6.1.1 Dfinition
Un arbre est un ensemble de nuds avec une relation de hirarchie entre Pre et Fils




Sous arbre


Remarque :
- Un arbre est :
- soit un arbre vide
- soit un nud racine et un ensemble de (sous)-arbres T1 ,, Tn de sorte ce que la
racine de Ti est connect par un lien direct la racine.
- la racine est un nud sans pre
- la feuille est un nud sans fils
- le nud interne est un nud admettant au moins un fils
Exemple







feuille
Fils
Pre et
Fils
feuille

racine
Nud interne
A
B C
C
D F
H G E

Pre et
Fils
Fils
Pre
Chapitre6 : Les arbres et les graphes


@quipe pdagogique Algorithmique2 53


Oprations sur les arbres
Il existe un certain nombre d'oprations classiques sur les arbres :
- Tester si larbre est vide ou non
- Crer un arbre ou une feuille
- Supprimer un nud ou la totalit de larbre
- Accder une valeur qui se trouve dans la racine.
6.1.2 Implmentation
Un arbre peut tre reprsent par un ensemble de nuds, chaque nud contient une valeur
et un tableau de N case qui contient des pointeurs pour les N fils du nud. N reprsente le
nombre maximal de fils que peut avoir un nud dans larbre.
Ainsi il se dfinit comme suit :
Type
Nud = Enreg
valeur : type
fils : Tableau [1..N] de ^Nud
FinEnreg
Arbre = ^Nud
Var
A : Arbre
La figure ci-dessous reprsente un arbre avec N= 3, donc chaque nud doit avoir au
maximum 3 fils.



6.1.3 Les fonctions daccs
Nous allons tudier un cas particulier des arbres : les arbres binaires. Un arbre binaire est un
arbre o tout nud a zro ou deux fils.
La reprsentation de la structure de donnes arbre binaire est constitue de 2 parties une pour
reprsenter un nud qui contient une valeur, un pointeur vers le nud gauche appel aussi
A
Chapitre6 : Les arbres et les graphes


@quipe pdagogique Algorithmique2 54

fils gauche et un pointeur vers le nud droit ou le fils droit ; et une autre partie qui constitue
la reprsentation de larbre sous forme dun pointeur vers un nud qui est la racine. On
travaille sur les valeurs de type entier.
Type
Nud = enreg
valeur : entier
fils_gauche : ^Nud
fils_droit : ^Nud
FinEnreg
Arbre_binaire = ^Nud

ArbreBinVide
Teste si un arbre binaire est vide ou non.
Fonction ArbreBinVide (A : Arbre_binaire) : Booleen
Debut
Si (A = Nil) Alors
Retourner (Vrai)
Sinon
Retourner (Faux)
FinSi
Fin
CreerFeuille
Cette fonction cre un nud contenant une valeur et retourne son adresse en mmoire.





A
Chapitre6 : Les arbres et les graphes


@quipe pdagogique Algorithmique2 55

Fonction CreerFeuille (v : entier) : Arbre_binaire
Var
F : Arbre_binaire
Debut
Allouer (F)
F^.valeur v
F^.fils_gauche Nil
F^.fils_droit Nil
Retourner (F)
Fin
CreerArbreBin
Cette fonction cre un arbre binaire partir dun sous arbre droit et un sous arbre gauche
existants et dune valeur mettre dans la racine enfin elle retourne ladresse de la racine.
Fonction CreerArbreBin (v : entier, fg : Arbre_binaire, fd : Arbre_binaire) : Arbre_binaire
Var
R : Arbre_binaire
Debut
Allouer (R)
R^.valeur v
R^.fils_gauche fg
R^.fils_droit fd
Retourner (R)
Fin



v
F
v
R
Chapitre6 : Les arbres et les graphes


@quipe pdagogique Algorithmique2 56

SupprimeArbreBin
Cette procdure permet de supprimer tous les nuds dun arbre binaire dont ladresse de sa
racine est fournie en paramtre.
Procedure SupprimeArbreBin (A : Arbre_binaire)
Debut
Si ( ArbreBinVide(A) = Faux ) Alors
SupprimeArbreBin (A^.fils_gauche)
SupprimeArbreBin (A^.fils_droit)
Liberer(A)
FinSi
Fin
Accs la racine
Cette fonction rcupre la valeur contenue dans le nud racine
Fonction Racine (A :Arbre_Binaire) : entier
Debut
Si (A<>Nil)
Retourner (A^.valeur)
Sinon
Ecrire( Erreur )
Fin Si
Fin
6.1.4 Niveau et hauteur dun arbre :
- Le niveau dun nud v est le nombre de ses anctres
- si v est la racine alors son niveau est 0
- sinon le niveau de v est : 1+ niveau du pre de v
- La hauteur dun nud v est dfinie par la dfinition suivante :
Chapitre6 : Les arbres et les graphes


@quipe pdagogique Algorithmique2 57

- si v est un nud feuille alors sa hauteur est 0
- sinon la hauteur de v est : 1+ maximum des hauteurs de ses fils
- La hauteur dun arbre est la hauteur de sa racine







- Nud b :
- niveau=1
- hauteur=2
- hauteur de larbre=3
6.1.5 Parcours dun arbre
6.1.5.1 Types de parcours
- Parcourir un arbre revient visiter ses nuds
- Visiter un nud revient effectuer un certain traitement sur ce nud qui dpend de
lapplication (affichage du contenu, modification dun attribut, calcul dune valeur, )
- Il existe 2 types de parcours :
o Le parcours en profondeur qui explore larbre branche par branche et peut tre
prfix, infix ou post fix :
Parcours prfix : on parcourt la racine puis le sous arbre gauche enfin le sous
arbre droit.
Parcours infix: on parcourt le sous arbre gauche puis la racine enfin le sous
arbre droit.
a
b c
d
f e g k h
l
Niveau 0
Niveau 1
Niveau 2
Niveau 3
Chapitre6 : Les arbres et les graphes


@quipe pdagogique Algorithmique2 58

Parcours postfix: on parcourt le sous arbre gauche puis le sous arbre droit
enfin la racine.
o Le parcours en largeur qui explore larbre niveau par niveau en commence par la
racine.
Parcours I nfix
Soit un arbre binaire dont les valeurs sont des entiers on veut crire une procdure rcursive
qui fait un parcours infix de cet arbre pour afficher les valeurs qui se trouvent dans tous les
nuds.
Procedure Infixe (A : Arbre_binaire)
Var
Debut
Si ( ArbreBinVide(A) = Faux ) Alors
Infixe (A^.fils_gauche)
Ecrire (A^.valeur)
Infixe (A^.fils_droit)
FinSi
Fin
Exemple
Si on prend larbre suivant :

Niveau 0 1


Niveau 1
2 3 4

Niveau 2
5 6 7
Chapitre6 : Les arbres et les graphes


@quipe pdagogique Algorithmique2 59


- Le parcours prfix donne : (1,2,5,6,3,4,7)
- Le parcours postfix donne : (5,6,2,1,3,7,4,1)
- Le parcours infix donne : (5,2,6,1,3,7,4)
- Le parcours en largeur donne : (1,2,3,4,5,6,7)
6.2 Les graphes
6.2.1 Dfinition
- Les graphes sont des structures de donnes qui permettent de reprsenter un grand nombre
de donnes : des rseaux, des plans, des trajets, etc.
- Un graphe orient est un couple G=(S, A) o :
- S reprsente un ensemble de sommets,
- A reprsente un ensemble darcs.
Soit a A, a= (u, v)
- u est appel origine de a,
- v est appel extrmit de a,
- u=prdcesseur (v)
- v=successeur (u)
- larc a est not uv
Exemple
S= {1, 2, 3, 4,5}
A= {(1,2), (1,3), (2,4), (2,5), (3,1), (3,3), (4,5), (5,1)}
1
3
5
4
2

Chapitre6 : Les arbres et les graphes


@quipe pdagogique Algorithmique2 60

6.2.2 Implmentation :
Pour implmenter un graphe, nous allons utiliser le mode de reprsentation par matrice
dadjacence.
Dans un graphe, il faux pouvoir bnficier des fonctionnalits suivantes :
- crer un graphe
- initialiser un graphe
- ajouter un arc dans un graphe
- supprimer un arc dans un graphe
- ajouter un sommet dans le graphe
- trouver le successeur dun sommet du graphe
Structure de donnes
Pour implmenter la structure de donnes graphe selon la reprsentation matricielle, nous
avons besoin de :
- un tableau deux dimensions pour dfinir le graphe
- un type de donnes sommet, dans ce cas un sommet est un entier (indice de ligne ou de
colonne de la matrice)
- un arc dfini par deux sommets : une origine et une extrmit.
Type
Sommet=entier
Arc = Enreg
Origine : Sommet
Extrmit : Sommet
FinEnreg
Graphe =Enreg
T : Tableau [1..Max][1..Max] de Sommet
NS : entier
FinEnreg
Avec NS=Nombre de sommets dans les graphes.
Max : nombre maximal pour le nombre de sommets du graphe
Cration du graphe
Pour crer un graphe, revient initialiser le nombre de sommet.
Chapitre6 : Les arbres et les graphes


@quipe pdagogique Algorithmique2 61

Fonction CreerGraphe(n :entier) :Graphe
Var G :Graphe
Debut
G.NS n
Allouer (G.T, n*n)
Retourner (G)
Fin
Initialisation du graphe
Cette fonction permet dinitialiser les cases de la matrice 0, le graphe une fois cre est
initialis, ensuite les arcs sont ajouts au fur et mesure des besoins de lapplication.
Fonction InitialiserGraphe(G :Graphe) :Graphe
Var i, j : entier
Debut
Pour i de 1 G.NS faire
Pour j de 1 G.NS faire
G.T[i,j]0
Fin Pour
Fin Pour
Retourner (G)
Fin
Ajout dun arc
Permet dattacher un arc pralablement cre au graphe
Fonction AjouterArc (G :Graphe, a :Arc) :Graphe
Debut
Si (a.origine >G.NS ou a.extrmit>G.NS ou a.origine <1 ou a.extrmit<1) alors
Ecrire ( Arc non dfini )
Sinon
G.T [a.origine , a.extrmit] 1
Fin Si
Retourner (G)
Fin
Chapitre6 : Les arbres et les graphes


@quipe pdagogique Algorithmique2 62

Suppression dun arc
Permet de supprimer un arc existant du graphe
Fonction SupprimerArc (G :Graphe, a :Arc) :Graphe
Debut
Si (a.origine >G.NS ou a.extrmit>G.NS ou a.origine <1 ou a.extrmit<1) alors
Ecrire ( Arc non dfini )
Sinon
G.T [a.origine, a.extrmit] 0
Fin Si
Retourner (G)
Fin
Ajout dun sommet
Cette fonction permet dajouter un sommet au graphe dans la limite de la taille prvue, et
initialise les arcs du nouveau sommet 0
Fonction AjouterSommet (G : Graphe, s : Sommet) :Graphe
Debut
Si (s>Max) alors
Ecrire ( Arc non dfini )
Sinon
G.NS=G.NS+1
Pour i de 1 G.NS faire
G.T [s, i] 0
G.T [i, s] 0
Fin pour
Fin Si
Retourner (G)
Fin
Successeur dun sommet
Recherche le premier successeur dun sommet du graphe. Cette fonction retourne le premier
successeur du sommet dans le graphe, et la valeur -1 sil nexiste pas de successeur
Fonction Successeur (G : Graphe, s : Sommet) : Sommet
Var Trouve : boolen
succ: Sommet
Chapitre6 : Les arbres et les graphes


@quipe pdagogique Algorithmique2 63

dbut
si (s<1) ou (S>G.NS) alors
Ecrire ( Sommet inexistant )
Sinon
Trouve faux
Succ 1
Tant que (succ<G.NS) et (trouve<>vrai) faire
Si (G.T[s,succ]=1) alors
Trouvevrai
Sinon
Succsucc+1
Fin Si
Fin Tant que
Si (trouve=vrai) alors
Retourner (succ)
Sinon
Retourner (-1)
Fin Si
Fin
Exemple
Nous allons crer le graphe suivant :
1
3
2

Algorithme Principal
Type
Sommet=entier
Arc = Enreg
Origine : Sommet
Extrmit : Sommet
FinEnreg
Graphe =Enreg
Chapitre6 : Les arbres et les graphes


@quipe pdagogique Algorithmique2 64

T : Tableau [1..Max][1..Max] de Sommet
NS : entier
FinEnreg
Var
G1 : Graphe
A : Arc
Dbut
G1CreerGraphe(3)
G1InitialisationGraphe(G1)
//1re arc
A.origine 1
A.extrmit 1
G1 AjouterArc(G1,A) ;

//2me arc
A.origine 1
A.extrmit 2
G1 AjouterArc(G1,A) ;

//3me arc
A.origine 1
A.extrmit 3
G1 AjouterArc(G1,A) ;

//4me arc
A.origine 3
A.extrmit 2
G1 AjouterArc(G1,A) ;
Fin



Chapitre 7 : Les algorithmes
rcursifs de recherche

Vue densemble
Ce Chapitre prsente les algorithmes de recherche rcursifs.

Objectifs
Ce chapitre a pour objectifs de permettre aux tudiants dacqurir les connaissances de
base se rapportant aux objectifs spcifiques suivants:
Etre capable dutiliser les algorithmes de recherches rcursifs sur des structures des donnes
dynamique (liste, pile, file, arbre, graphe).
Savoir crire un algorithme de recherche sur une structure de donnes dune faon
rcursive

Pr-requis
Algorithmique 1
Les enregistrements
Les pointeurs
La rcursivit
Les listes
Les arbres et les graphes

Dure
6 H

Elments de contenu
1. Dfinition
2. Recherche dans une liste chane
3. Recherche dans un arbre binaire
Chapitre7 : Les algorithmes rcursifs de recherches


quipe pdagogique Algorithmique2 65

7.1 Dfinition

Un algorithme de recherche est un type d'algorithme qui cherche, parmi une liste de
donnes, les lments satisfaisant certains critres.
En gnral, le critre de recherche porte sur la valeur d'une cl (ex : chercher un numro de tel
dans un ensemble de personnes (une personne=nom + adresse + tel...), rechercher un mot dans
un dictionnaire (dictionnaire=mots+dfinitions+photo+...), ...). Cette cl peut aussi tre
simplement la valeur de l'objet (recherche d'un entier dans une liste d'entier, ...).
Les algorithmes de recherche que nous allons prsenter retournent un lment quelconque
ayant une cl de la valeur cherche. Il est parfois plus utile de retourner la place de cet
lment dans l'ensemble des donnes (pour par exemple effectuer ensuite une suppression,
...).
7.2 Recherche dans une liste chaine
7.2.1 Recherche squentielle
La recherche squentielle est une mthode de recherche qui consiste chercher un lment
dans une liste d'lments de mme type. On commence du premier lment de la liste jusqu'
ce qu'on trouve l'lment. Si on ne le trouve pas, alors on aura parcouru toute la liste. Si on
teste souvent une liste et si ces lments sont rpartis de manire alatoire, le nombre moyen
d'lments comparer pour savoir si un lment est dans la liste ou non est de : N/2 o N est
le nombre d'lments de la liste.
7.2.2 Recherche par valeur
La fonction recherche par valeur retourne un pointeur vers le premier lment trouv dont la
valeur est passe en paramtre, ou le pointeur nil si aucun lment n'a t trouv
Fonction recherche_valeur (L: Liste, val:entier): Liste
Dbut
si (L=nil ) alors
Retourner (nil)
sinon
si (L^.valeur = val) alors
Retourner(L)
sinon
Retourner recherche_valeur (L^.suivant,val)
finsi
finsi
Chapitre7 : Les algorithmes rcursifs de recherches


quipe pdagogique Algorithmique2 66
fin
7.2.3 Recherche par position
La fonction recherche par position retourne un pointeur vers l'lment ayant la position passe
en paramtre. Si la liste contient moins dlments que le paramtre position, le pointeur nil
est retourn.
Fonction recherche_postion (L: Liste, pos:entier): Liste
Dbut
si (L=nil ou pos=1) alors
Retourner(L)
sinon
Retourner recherche_position (L^.suivant , pos-1)
finsi
fin
7.2.4 Recherche dichotomique
La dichotomie consiste diviser une liste de donnes en deux sous-listes. La recherche
dichotomique consiste dcomposer une liste en deux sous-listes A et B puis dterminer si
l'lment recherch se trouve en A ou B. Puis on redcoupe en deux sous-listes C et D, la
sous-liste o se trouve l'lment puis on dtermine si l'lment recherch se trouve en C ou D.
On rpte l'opration tant qu'on n'a pas trouv l'lment ou que les sous-listes restantes ne
soient composes plus que d'un seul lment, puisqu'on n'a pas dcompos une liste d'un seul
lment. Dans ce cas, on considre que l'lment n'est pas dans la liste recherche.
La mthode par dichotomie est une des mthodes de recherche la plus rapide, le
problme essentiel de la recherche dichotomique est la ncessit que les lments de la liste
soient tris (croissant ou dcroissant).
7.2.5 Recherche dans une liste ordonne
Principe :
On regarde l'lment au milieu de la liste :
- Sil est gal la valeur cherche, c'est fini
- Sil est infrieur la valeur cherche, il ne reste traiter que la moiti droite de la liste
- Sil est suprieur la valeur cherche, il ne reste traiter que la moiti gauche de la
liste
Chapitre7 : Les algorithmes rcursifs de recherches


quipe pdagogique Algorithmique2 67
On continue ainsi la recherche en diminuant chaque fois de moiti le nombre d'lments de
la liste restant traiter.
Pour raliser la recherche dichotomique dans une liste trie, la fonction Recherche_dicho est
implmente, elle prend 4 paramtres : llment x cherche, L : la tte de la liste chane,
le dbut et la fin de la sous liste dans la quelle x est cherche.
Dans lalgorithme principal, lappel sera comme suit :
Recherche_dicho(x, L, 1, longueur (L))
Avec longueur (L) est une fonction qui renvoi la longueur de la liste chane.
Fonction Recherche_dicho(x : entier, L : Liste, debut : entier, fin:entier) : Boolen
Var
Rang, milieu, e : entier
Dbut
si debut<=fin alors
milieu (fin+debut) div 2
e ieme(milieu,L)
si (x=e) alors
// on a trouve l'element
retourner VRAI
sinon
si (x<e) alors
// il est peut tre dans la moiti gauche
retourner Recherche_dicho(x, L, debut, milieu-1)
sinon // il est peut tre dans la moiti droite
retourner Recherche_dicho(x, L, milieu+1, fin)
finsi
finsi
sinon
// la liste traiter est vide
retourner FAUX
finsi
fin

Chapitre7 : Les algorithmes rcursifs de recherches


quipe pdagogique Algorithmique2 68
La fonction ieme(milieu, L) est une fonction qui retourne la valeur de la cellule ayant la
position milieu de la liste L.
Fonction ieme(pos : entier, L : Liste) : entier
Var
P : Liste
i : entier
Dbut
P L
i 1
Tantque (i < pos) faire
P P^.suivant
i i + 1
fin tantque
retourner P^.valeur
Fin
La fonction longueur (L) est une fonction qui calcule la longueur dune liste chane L.
Fonction longueur (L : Liste) : entier
Var
P : Liste
nb : entier //nb est le nombre dlment de la liste
Dbut
P L
nb 0
Tantque (P<>Nil) faire
nb nb + 1
P P^.suivant
fin tantque
Retourner (nb)
Fin



Chapitre7 : Les algorithmes rcursifs de recherches


quipe pdagogique Algorithmique2 69


7.3 Recherche dans un arbre binaire

La recherche dans un arbre binaire d'un nud ayant une valeur particulire est un procd
rcursif. On commence par examiner la racine. Si sa valeur est la valeur recherche,
l'algorithme se termine et renvoie la racine. Si elle est strictement infrieure, alors elle est
dans le sous-arbre droit, sur lequel on effectue alors rcursivement la recherche. De mme si
la valeur de la racine est strictement suprieure la valeur recherche la recherche continue
sur le sous-arbre gauche. Si on atteint une feuille dont la valeur n'est pas celle recherche, on
sait alors que la valeur recherche n'appartient aucun nud. On peut la comparer avec la
recherche par dichotomie qui procde peu prs de la mme manire.
7.3.1 Parcours en profondeur
Le parcours en profondeur est un parcours rcursif sur un arbre. Il existe trois ordres pour
cette mthode de parcours.
7.3.1.1 Parcours prfix
Dans ce mode de parcours, on traite la racine, puis le sous-arbre gauche, puis le sous-arbre
droit.

Ainsi, un parcours prfix pour cet arbre va nous donner comme rsultat :
11- 8 -5 -10 -14 -13 -15
La procdure rcursive de la recherche prfixe est :
Procdure prfix ( A : Arbre )
Dbut
si (A < > nil) alors
Chapitre7 : Les algorithmes rcursifs de recherches


quipe pdagogique Algorithmique2 70
traiter(A)
prfix(A^.FilsG)
prfix(A^.FilsD)
finsi
Fin
Remarque :
- Traiter(A) : est le traitement exercer sur larbre de racine A, ajout, suppression,
recherche, affichage,
7.3.1.2 Parcours infix
Dans ce mode de parcours, on traite le sous-arbre gauche, puis la racine, puis le sous-arbre
droit.

Ainsi un parcours infix pour cet arbre va nous donner comme rsultat :
5 8 10 11 13 14 15
La procdure rcursive de la recherche infixe est :
Procdure infix ( A : Arbre )
Dbut
si (A < > nil) alors
infix(A^.FilsG)
traiter(A)
infix(A^.FilsD)
finsi
Fin
Chapitre7 : Les algorithmes rcursifs de recherches


quipe pdagogique Algorithmique2 71
7.3.1.3 Parcours postfix
Dans ce mode de parcours, on traite le sous-arbre gauche, le sous-arbre droit, puis la racine.


La procdure rcursive de la recherche postfixe est :
Procdure postfix (A : Arbre )
Dbut
si (A < > nil) alors
postfix(A^.FilsG)
postfix(A^.FilsD)
traiter(A)
finsi
Fin

7.3.2 Application
Recherche rcursive du pre dune valeur dans un sous arbre de racine A :
Algorithme pere(x : entier, A : Arbre): Arbre

Var
tmp, P : Arbre
Dbut
si (A=Nil) alors
Retourner (Nil)
sinon
P A
Chapitre7 : Les algorithmes rcursifs de recherches


quipe pdagogique Algorithmique2 72
si (P^.valeur=x) alors
Retourner (Nil) // cas particulier pere de la racine
sinon
si (P.FilsG^.valeur=x) ou ( P.FilsD^.valeur=x) alors
Retourner (P)
sinon
tmp pere(x, P^.FilsG) // recherche rcursive dans le SAG
si (tmp=Nil) alors
// s'il n'est pas gauche, c'est qu'il est droite
tmp pere(x, P^.FilsD)
finsi
Retourner (tmp)
finsi
finsi
finsi
Fin
7.3.3 Arbre binaire de recherche
Un arbre binaire de recherche (ABR) est un arbre binaire tel que la valeur stocke dans
chaque sommet est suprieure celles stockes dans son sous-arbre gauche et infrieur
celles de son sous-arbre droit.
Exemple :

Algorithme de recherche dans un arbre binaire de recherche:
Chapitre7 : Les algorithmes rcursifs de recherches


quipe pdagogique Algorithmique2 73
Algorithme Recherche(e : entier, B : arbre) : boolen
// vrifier si e appartient au sous-arbre B (qui peut tre vide)
Dbut
Si (B=Nil) Alors // l'lment n'est pas dans l'arbre
Retourner FAUX
Sinon
Si (e=B^.valeur) Alors // on l'a trouv
Retourner VRAI
Sinon
Si (e<B^.valeur) Alors
// s'il existe, c'est dans le sous-arbre gauche
Retourner Recherche(e, B^.FilsG)
Sinon
// s'il existe, c'est dans le sous-arbre droit
Retourner Recherche(e, B^.FilsD)
Finsi
Finsi
Finsi
fin




Chapitre 8: Complexit des
algorithmes

Vue densemble
Ce Chapitre prsente la complexit des algorithmes.

Objectifs
Ce chapitre a pour objectifs de permettre aux tudiants dacqurir les connaissances de
base se rapportant aux objectifs spcifiques suivants:
Etre capable dvaluer un algorithme en calculant sa complexit
Savoir calculer la complexit dun algorithme.

Pr-requis
Algorithmique 1
Algorithmique 2

Dure
3 H

Elments de contenu
1. Introduction
2. Dfinition
3. Calcule de la complexit
4. Type de la complexit
5. Complexit de quelque algorithme
Chapitre8 : Complexit des algorithmes


quipe pdagogique Algorithmique2 74

8.1 Introduction

Un algorithme est une procdure finie et un enchanement des tapes de rsolution dun
problme. Un algorithme doit tre appliqu sur toutes les donnes possibles du problme et
doit fournir une solution correcte dans chaque cas. En informatique, il est possible de rsoudre
un problme donn par implantation dun algorithme conu spcification pour la rsolution.
Cependant, pour un problme donn, il peur tre rsolu souvent avec plusieurs algorithmes.
Le problme qui se pose alors : Comment choisir entre les algorithmes? Comment dterminer
lefficacit dun algorithme par rapport un autre ? De ces questions est ne la complexit des
algorithmes.
8.2 Dfinition
La mesure de la complexit dun algorithme est une estimation de son temps dexcution
ainsi que de lespace mmoire utilis. Ces 2 mesures sont appeles complexit spatiale et
temporelle de lalgorithme.
- La complexit spatiale exprime la taille occupe par les donnes de lalgorithme dans la
mmoire de lordinateur.
- La complexit temporelle exprime le temps que prendra lexcution de l'algorithme.
La mesure de la complexit permet de dcider si un algorithme est efficace ou non
indpendamment de la machine qui va lexcuter et du langage dimplmentation, elle ne
dpend que de lalgorithme lui-mme.
8.3 Calcul de la complexit
Le temps dexcution dun algorithme est fonction du nombre doprations lmentaires dans
cet algorithme. Par exemple, pour le parcourt dun tableau et la recherche dun lment
donne, la comparaison entre llment courant du tableau et llment recherch sera prise en
compte.
La complexit dun algorithme dpend de plusieurs facteurs, tel que la taille des donnes
traiter et le type doprations effectuer, par exemple une addition est plus rapide quune
multiplication.
Il nexiste pas de mthode formelle pour calculer la complexit dun algorithme mais il y a
des rgles qui peuvent tre appliques.
On note T (Op) : le temps dexcution dune oprations Op, voici les rgles qui peuvent tre
appliqu lors du calcul du temps dexcution dun algorithme :

Chapitre8 : Complexit des algorithmes


quipe pdagogique Algorithmique2 75
- Si Op est une instruction lmentaire alors T (Op) est considr comme constant et il
est not O(1).
- Si Op est une instruction conditionnelle (si condition alors op1 sinon op2) alors T (Op)
est estim T (condition) + Max (T (op1) + T (op2)).
- Si Op est une boucle (Pour i de 1 N faire Operation) alors T (Op) est estim
Somme (T (Operation) ) qui reprsente la somme des temps des oprations de chaque
itration.
8.4 Type de complexit
Les algorithmes usuels peuvent tre classs en un certain nombre de grandes classes de
complexit.
Les algorithmes sous-linaires, dont la complexit est en gnral en O(log n). C'est le
cas de la recherche d'un lment dans un ensemble ordonn fini de n lments
(recherche dun lment dans un tableau de taille n).
Les algorithmes linaires en complexit O(n) sont considrs comme rapides, comme
l'valuation de la valeur d'une expression compose de n symboles ou les algorithmes
de tri de tableaux de n lments.
Plus lents sont les algorithmes de complexit situe entre O(n
2
) et O(n
3
), c'est le cas de
la multiplication des matrices de taille n.
Puisque on calcule la complexit temporelle en faisant une approximation, on utilise donc les
notations suivantes:
O(1) :complexit constante
O(log(n)) :complexit logarithmique
O(n) : complexit linaire
O(n
2
) : complexit quadratique
O(n
3
) : complexit cubique
O(n
p
) : complexit polynomiale
O(2
n
) : complexit exponentielle

Chapitre8 : Complexit des algorithmes


quipe pdagogique Algorithmique2 76
8.5 Complexit de quelques algorithmes
8.5.1 Recherche du plus petit lment
Soit l'exemple suivant:
fonction plusPetit (x: Tableau[1..n] de entier)
var k,i: entier
Debut
k0
pour i de 1 n faire

si(x[i] < x[k]) alors
k i
finsi
finpour
Retourner (k)
Fin
Dans cette fonction, on excute n-1 tests de comparaison. La complexit temporelle est donc
n-1 elle est not O(n).
8.5.2 Produit de matrice
Soit l'exemple suivant:
Algorithme Produit_Matrice
var
u,v, w : Tableau[1..n] de entier
i : entier
Debut
pour i de 1 n faire
pour j de 1 n faire
w[i,j] u[i,j] * v[i,j]
finpour
fin pour
fin

Chapitre8 : Complexit des algorithmes


quipe pdagogique Algorithmique2 77
La complexit temporelle de cet algorithme est la somme des temps ncessaire pour faire les
multiplications sur une ligne de la matrice w savoir n * le temps dune multiplication qui est
considr comme constante donc O(n). Ce calcul est rpt pour chaque ligne donc la
complexit prcdente doit tre multiplie par n.
Finalement on peut en dduire que lalgorithme est de complexit gale O(n
2
).
8.6 Exercices dapplication

Exercice 1 :
Donnez la complexit des programmes suivants
(a) pour i = 1 n faire
pour j = 1 n faire
x + 3

(b) pour i = 1 n faire
pour j = 1 i faire
x + 3

(c) pour i = 5 n-5 faire
pour j = i-5 i+5 faire
x + 3

(d) pour i = 1 n faire
pour j = 1 n faire
pour k = 1 n faire
4 x x+a

(f) pour i = 1 n faire
pour j = 1 i faire
pour k = 1 j faire
x x+a


Exercice 2 :
Soit lalgorithme suivant:
Fonction Partition (var T : tableau [1..N] de entier, deb, fin : entier) : entier
Var
i, j, v, p: entier
Debut
i deb-1
j fin
p T[fin]
Repeter
Repeter
i i+1
Jusqu' ( T[i] p )
Chapitre8 : Complexit des algorithmes


quipe pdagogique Algorithmique2 78
Repeter
j j-1
Jusqu' ( T[j] p )
Si ( i< j) Alors
v T[i]
T[i] T[j]
T[j] v
FinSi
Jusqu' ( i j )
T[fin] T[i]
T[i] p
Retourner (i)
Fin
Procedure Tri_Rapide (var T : tableau[1..N] de entier, deb, fin :entier)
Var
Pos : entier
Debut
Si (deb < fin) Alors
Pos Partition (T,deb,fin)
Tri_Rapide (T,deb,pos-1)
Tri_Rapide (T,pos+1,fin)
FinSi
Fin

Dterminer la complexit de la procdure Tri_Rapide
8.7 Solutions des exercices
Exercice 1 :
a- O(N)
b- O (N
2
)
c- O (N
2
)
d- O (N
3
)
f- O (N
3
)
Exercice 2 :
O (log(n))












DS et examen







Bibliographie



Livres
[1]: Amina Bouraoui baccar, Algorithmique avance et structures de donnes cours et
applications.
[2]: Warin Bruno, Lalgorithmique votre passeport informatique pour la programmation,
Ellipses, 2002
[3]: ROHAUT, Algorithmique et Techniques fondamentale de programmation, Edition Eni
2007
[3]: LIGNELET P., Algorithmique. Mthodes et modles, Paris : Masson, 1985
Sites Web

[1]: www.intelligentedu.com/blogs/post/free_computer_books/3760/the-algorithm-design-
manual/fr/