Polycope Algo2

REPUBLIQUE ALGERIENNE DEMOCRATIQUE ET POPULAIRE
MINISTERE DE LENSEIGNEMENT SUPERIEUR ET DE LA RECHERCHE

SCIENTIFIQUE
UNIVERSITE MOHAMED KHIDER BISKRA
FACULTE DES SCIENCES EXACTES ET DES SCIENCES DE LA NATURE ET DE LA VIE
DEPARTEMENT DINFORMATIQUE

Ouvrage Pdagogique

ALGORITHMIQUE ET STRUCTURES DE
DONNEES 1

Niveau : 2
me
anne LMD (troisime semestre)

Prpar par :
Abdelhamid Djeffal (MAA)

Anne universitaire : 2009/2010
Algo 1, 2LMD, Informatique
1
Sommaire

I. Introduction............................................................................................................................................ 3
1.Notion dalgorithme................................................................................................................................ 4
2. Langage algorithmique utilis................................................................................................................ 5
II. Complexit des algorithmes................................................................................................................... 6
1. O-notation .............................................................................................................................................. 6
2. Rgles de calcul de la complexit dun algorithme : ............................................................................. 6
3. Complexit des algorithmes rcursifs.................................................................................................. 10
4. Types de complexit algorithmique..................................................................................................... 11
III. Structures squentielles.................................................................................................................... 12
1. Les listes linaires chanes ................................................................................................................. 12
Notion d'allocation dynamique ............................................................................................................ 12
Dfinition d'une liste linaire chane.................................................................................................. 12
Reprsentation relle en mmoire........................................................................................................ 13
Modle sur les listes linaires chanes ............................................................................................... 13
Algorithmes sur les listes linaires chanes........................................................................................ 14
Listes linaires chanes bidirectionnelles........................................................................................... 15
Modle sur les listes linaires chanes bidirectionnelles.................................................................... 15
2. Les piles (stacks).................................................................................................................................. 16
Utilisation des piles.............................................................................................................................. 16
Oprations sur les piles ........................................................................................................................ 17
Reprsentation des piles....................................................................................................................... 17
3. Les Files dattente (Queues) ................................................................................................................ 21
Utilisation des files dattente ............................................................................................................... 21
Oprations sur les files dattente.......................................................................................................... 21
Implmentation des files dattente....................................................................................................... 21
File dattente particulire (File dattente avec priorit) ....................................................................... 25
IV. Structures hirarchiques................................................................................................................... 26
1. Les arbres ............................................................................................................................................. 26
Dfinitions............................................................................................................................................ 26
Utilisation des arbre ............................................................................................................................. 28
Implmentation des arbres ................................................................................................................... 29
Modle sur les arbres ........................................................................................................................... 30
Traitements sur les arbres .................................................................................................................... 30
Typologie des arbres............................................................................................................................ 33
2. Les arbres binaires de recherche.......................................................................................................... 34
Implmentation des ABR..................................................................................................................... 34
Modle sur les ABR............................................................................................................................. 35
Traitements sur les ABR...................................................................................................................... 35
3. Les tas .................................................................................................................................................. 38
Dfinition............................................................................................................................................. 38
Oprations sur les tas ........................................................................................................................... 38
Implmentation des tas : ...................................................................................................................... 40
V. Structures en tables .............................................................................................................................. 41
Fonctions de Hachage :........................................................................................................................ 43
Problme de collisions ......................................................................................................................... 43
VI. Les Graphes ..................................................................................................................................... 46
1. Dfinitions............................................................................................................................................ 46
2. Reprsentation...................................................................................................................................... 47
2
3. Parcours de graphes ............................................................................................................................. 49
En profondeur dabord (DFS) :............................................................................................................ 49
En largeur dabord (BFS)..................................................................................................................... 50
4. Plus court chemin (algorithme de Dijkstra) ......................................................................................... 50
Algorithme de Dijkstra ........................................................................................................................ 51
VII. Preuve dalgorithmes ....................................................................................................................... 52
1. Terminaison ......................................................................................................................................... 52
2. Correction partielle .............................................................................................................................. 52
3. Correction totale................................................................................................................................... 52
4. Outils de preuve dalgorithme (Logique de Hoare)............................................................................. 53
VIII. Exercices avec et sans solutions ...................................................................................................... 56
1. Complexit algorithmique .................................................................................................................. 56
2. Listes linaires chanes....................................................................................................................... 60
3. Piles et Files ......................................................................................................................................... 72
4. Arbres................................................................................................................................................... 79
5. Structures en tables et graphes............................................................................................................. 92
6. Preuve de programmes....................................................................................................................... 101
IX. Bibliographie.................................................................................................................................. 102

3

I. Introduction

L'utilisation d'un ordinateur pour la rsolution d'un problme ncessite tout un travail de prparation.
N'ayant aucune capacit d'invention, l'ordinateur ne peut en effet quexcuter les ordres qui lui sont
fournis par l'intermdiaire d'un programme. Ce dernier doit donc tre tabli de manire envisager toutes
les ventualits d'un traitement.
Exemple : le problme Div(a,b), noubliez pas le cas b=0 !
Rsolution dun problme en informatique
Plusieurs tapes sont ncessaires pour rsoudre un problme en informatique:
Etape 1 : Dfinition du problme
Il sagit de dterminer toutes les informations disponibles et la forme des rsultats dsirs.
Etape 2 : Analyse du problme
Elle consiste trouver le moyen de passer des donnes aux rsultats. Dans certains cas on peut tre
amen faire une tude thorique. Le rsultat de ltape danalyse est un algorithme. Une premire
dfinition dun algorithme peut tre la suivante :
On appelle algorithme une suite finie d'instructions indiquant de faon unique l'ordre dans lequel
doit tre effectu un ensemble d'oprations pour rsoudre tous les problmes d'un type donn.
Sachez aussi quil existe des problmes pour lesquels on ne peut trouver une solution et par
consquent il est impossible de donner lalgorithme correspondant.
Etape 3 : Ecriture d'un algorithme avec un langage de description algorithmique.
Une fois quon trouve le moyen de passer des donnes aux rsultats, il faut tre capable de rdiger
une solution claire et non ambigu. Comme il est impossible de le faire en langage naturel, lexistence
dun langage algorithmique simpose.
Etape 4 : Traduction de l'algorithme dans un langage de programmation.
Les tapes 1, 2 et 3 se font sans le recours de la machine. Si on veut rendre lalgorithme concret ou
pratique, il faudrait le traduire dans un langage de programmation. Nous dirons alors quun programme est
un algorithme exprim dans un langage de programmation.
Etape 5 : Mise au point du programme
Quand on soumet le programme la machine, on peut tre confront deux types de problmes :
-la machine corrige lorthographe, cest ce quon appelle syntaxe dans le jargon de la
programmation.

4
-la machine traduit le sens exprim par le programme.
Si les rsultats obtenus sont ceux attendus, la mise au point du programme se termine.
Si nous nobtenons pas de rsultats, on dira quil y a existence des erreurs de logique. Le programme
soit ne donne aucun rsultat, soit des rsultats inattendus soit des rsultats partiels.
Dans ce cas, il faut revoir en priorit si lalgorithme a t bien traduit, ou encore est-ce quil y a eu
une bonne analyse.
1.Notion dalgorithme
-Dfinition
On peut dfinir un algorithme comme suit :
- Rsultat d'une dmarche logique de rsolution d'un problme. Cest le rsultat de l'analyse.
Ou encore :
- Une squence de pas de calcul qui prend un ensemble de valeurs comme entre (input) et produit
un ensemble de valeurs comme sortie (output).
-Proprits
On peut noncer les cinq proprits suivantes que doit satisfaire un algorithme :
- Gnralit : un algorithme doit toujours tre conu de manire envisager toutes les ventualits
d'un traitement.
- Finitude : Un algorithme doit sarrter au bout d'un temps fini.
- Dfinitude : toutes les oprations d'un algorithme doivent tre dfinies sans ambigut
- Rptitivit : gnralement, un algorithme contient plusieurs itrations, cest dire des actions qui se
rptent plusieurs fois.
- Efficacit : Idalement, un algorithme doit tre conu de telle sorte quil se droule en un temps
minimal et quil consomme un minimum de ressources.
-Exemples
o PGCD (Plus Grand Commun Diviseur) de deux nombres u et v.
Algorithme naf : on teste successivement si chaque nombre entier est diviseur
commun.
Dcomposition en nombres premiers.
o Algorithmes de tri
o Algorithmes de recherche
Recherche d'une chane de caractre dans un texte (Logiciels de traitement de
texte).
Recherche dans un dictionnaire
-Remarque :
Attention, certains problmes n'admettent pas de solution algorithmique exacte et utilisable. On
utilise dans ce cas des algorithmes heuristiques qui fournissent des solutions convenables.

2. Langage algorithmique utilis
Durant ce cours, on va utiliser un langage algorithmique pour la description des diffrentes solutions
apportes aux problmes abords. Lalgorithme suivant rsume la forme gnrale dun algorithme et la
plupart des dclarations et instructions utilises.
Algorithme Premier_Exemple ;

Type TTab : tableau[1..10] de real ;

Const Pi = 3.14 ;

Procedure Double(x :entier) ;
Debut
x x * 2 ;
Fin ;

Fonction Inverse (x :reel) :reel ;
Debut
Inverse 1/x ;
Fin ;

Var i, j, k :entier ;
T:TTab;
S:chaine;
R:Reel;

Debut
Ecrire ( Bonjour, donner un nombre entier < =10:);
Lire (i) ;
Si i>10 alors Ecrire ( Erreur i doit tre <=10)
Sinon
5
Pour j1 j faire
Lire(R) ;
T[j] Double(R) ;
FPour ;

k 1 ;
TQ k<=i Faire
Ecrire (T[k]*Inverse(Pi)) ;
FTQ ;

S Programme termin ;
Ecrire(S) ;
FSi

Fin.

6
II. Complexit des algorithmes
Introduction
Le temps dexcution dun algorithme dpend des facteurs suivants :
1. Les donnes du programme
2. La qualit du compilateur (langage utilis)
3. La machine utilise (vitesse, mmoire,)
4. La complexit de lalgorithme lui-mme
On cherche mesurer la complexit dun algorithme indpendamment de la machine et du langage
utiliss, c--d uniquement en fonction de la taille des donnes n que lalgorithme doit traiter. Par exemple
dans le cas de tri dun tableau n est le nombre dlment du tableau, et dans le cas de calcul dun terme
dune suite n est lindice du terme
Soit la fonction T(n) qui reprsente lvolution du temps dexcution dun programme P en
fonction du nombre de donnes n.
Par exemple :
T(n)=cn
2

O c est une constante non spcifie qui reprsente la vitesse de la machine les performances du
langage,etc.
1. O-notation
On dit dans lexemple suivant que la complexit de P est O(n
2
), cela veut dire quil existe une
constante c positive tel que pour n suffisamment grand on a :
T(n)<=cn
2

Cette notation donne une majoration du nombre doprations excutes (temps dexcution) par le
programme P.
Un programme dont la complexit est O(f(n)) est un programme qui a f(n) comme fonction de
croissance du temps dexcution.
2. Rgles de calcul de la complexit dun algorithme :
1. La complexit dune instruction lmentaire (affectation, lecture, criture, comparaison) est
O(1)
Une opration lmentaire est une opration dont le temps dexcution est indpendant de la
taille n des donnes.
2. O(c * f(n)) = O(f(n)) exemple O( n
3
/4) = O(n
3
).
3. La complexit dune squence de 2 modules M1 de complexit O(f(n)) et M2 de complexit
O(g(n)) est gale la plus grande des complexit des deux modules : O( max(f(n),g(n)) )
O(f(n)) + O(g(n)) = O(max( f(n) , (g(n))

4. La complexit dune conditionnelle (Si cond Alors M1 Sinon M2 Fsi) est le max entre les
complexits de lvaluation de cond, M1 et M2.
O(h(n))
Si Cond Alors
M1 O(f(n))
Sinon O(max(h(n), f(n) , g(n) ))
M2 O(g(n))
Fsi

5. La complexit dune boucle est gale la somme sur toutes les itrations de la complexit du corps
de la boucle
O(h(n))
Tantque Condition Faire n fois
P O(f(n)) O(
n
Max(h(n),f(n))
FinTq

Exemple 1
Algorithme Recherche ;
Var T :tableau[1..n] de entier ;
x,i :entier ;
trouv : booleen ;
debut
Pour i=1 n faire n fois
Lire (T[i]) ; O(1) O(
n
1) = O(n)
Fpour
Lire(x) ; O(1)
Trouv faux ; O(1) O(1)
i 1 ; O(1)
Tantque trouv=faux et i<=n faire n fois
7

Si T[i]=x alors O(1)
Trouv vrai O(1) O(1) O(
n
1) = O(n)
i i + 1 ; O(1)
FTq
Si trouv=vrai alors O(1)
Ecrire (x,existe) O(1)
Sinon O(1)
Ecrire (x, nexiste pas) O(1)
Fin.
La complexit de lalgorithme est de O(n) + O(n) + O(1) = O(n).
Exemple 2
8
Pour i1 n faire n fois
Pour ji+1 , n faire n-i fois
Si T[i] > T[j] alors
tmp T[i]; O(1) O(
n

-i
* 1) = O(n-i)
T[i] T[j]; O(1) O(1) O(
n
(n-i))
T[j] tmp; O(1)
Fsi
Fpour
Fpour
La complexit = O(
n
(n-i)) = O((n-1) + (n-2) + 1)=O(n(n+1)/2)= O(n
2
/2 + n/2)= O(n
2
)

Exemple 3 : Recherche dichotomique
Algorithme Recherche ;
Var T :tableau[1..n] de entier ;
x,sup,inf,m :entier ;
trouv : booleen ;
debut
Lire(x) ; O(1)
9
Trouv faux ; O(1)
inf 1 ; O(1) O(1)
sup n ; O(1)
Tantque trouv=faux et inf<sup faire log
2
(n) fois
m (inf + Sup ) div 2 ; O(1)
Si T[m]=x alors O(1)
Trouv vrai O(1)
Sinon O(1)
Si T[m]<x alors O(1) O(1)
inf m +1 O(1)
Sinon O(1)
Sup m -1 O(1)
Fsi
Fsi O(
log2(n)
1)
FTq
Si trouv=vrai alors O(1) = O(log
2
(n))
Ecrire (x,existe) O(1)
Sinon O(1)
Ecrire (x, nexiste pas) O(1)
Fsi
Fin.

10
La complexit de lalgorithme est de O(1) + O(log
2
(n)) + O(1) = O(log
2
(n))=O(log(n)).
3. Complexit des algorithmes rcursifs
La complexit dun algorithme rcursif se fait par la rsolution dune quation de rcurrence en liminant
la rcurrence par substitution de proche en proche.
Exemple 1
Soit la fonction rcursive suivante :

Fonction Fact(n:entier) : entier
Debut
Si n <= 1 alors O(1)
Fact 1 O(1)
Sinon
Fact n * Fact(n - 1) ?
Fsi
Fin;
Posons T(n) le temps dexcution ncessaire pour un appel Fact(n), T(n) est le max entre :
la complexit du test n<=1 qui est en O(1)
la complexit de : Fact 1 qui est aussi en O(1)
la complexit de : Fact n*Fact(n - 1) dont le temps dexcution dpend de T(n - 1) (pour le
calcul de Fact(n - 1))
On peut donc crire que :
T(n) = a si n<=1 et,
T(n) = b+T(n - 1) sinon (si n>1)
La constante a englobe le temps du test (n<=1) et le temps de laffectation (Fact 1)
La constante b englobe :
le temps du test (n<=1)
le temps de lopration * entre n et le rsultat de Fact(n-1)
et le temps de laffectation finale (Fact ...)
T(n - 1) (le temps ncessaire pour le calcul de Fac(n - 1)) sera calcul (rcursivement) avec la mme
dcomposition.
Pour calculer la solution gnrale de cette quation, on peut procder par substitution:

11
T(n) = b + T(n - 1)
= b + [b+T(n - 2)]
= 2b + T(n - 2)
= 2b + [b+T(n - 3)]
= ...
= ib + T(n - i)
= ib + [b+T(n - i+ 1)]
= ...
= (n - 1)b + T(n n + 1) = nb - b + T(1) = nb - b + a
T(n) = nb b + a
Donc Fact est en O(n) car b est une constante positive.

4. Types de complexit algorithmique
T(n) = O(1), temps constant : temps dexcution indpendant de la taille des donnes traiter.
T(n) = O(log(n)), temps logarithmique : on rencontre gnralement une telle complexit lorsque
lalgorithme casse un gros problme en plusieurs petits, de sorte que la rsolution dun seul de ces
problmes conduit la solution du problme initial.
T(n) = O(n), temps linaire : cette complexit est gnralement obtenue lorsquun travail en temps
constant est effectu sur chaque donne en entre.
T(n) = O(n.log(n)) : lalgorithme scinde le problme en plusieurs sous-problmes plus petits qui sont
rsolus de manire indpendante. La rsolution de lensemble de ces problmes plus petits apporte la
solution du problme initial.
T(n) = O(n), temps quadratique : apparat notamment lorsque lalgorithme envisage toutes les paires de
donnes parmi les n entres (ex. deux boucles imbriques)
Remarque : O(n
3
) temps cubique
T(n) = O(2
n
), temps exponentiel : souvent le rsultat de recherche brutale dune solution.

III. Structures squentielles
1. Les listes linaires chanes
Notion d'allocation dynamique
L'utilisation des tableaux statiques implique que l'allocation de l'espace se fait tout fait au dbut
d'un traitement, c'est dire que l'espace est connu la compilation.
Pour certains problmes, on ne connat pas l'avance l'espace utilis par le programme. On est
donc contraint utiliser une autre forme d'allocation. L'allocation de l'espace se fait alors au fur et
mesure de l'excution du programme.
Afin de pratiquer ce type d'allocation, deux oprations sont ncessaires : allocation et libration de
l'espace.
Exemple
Supposons que l'on veuille rsoudre le problme suivant : " Trouver tous les nombres premiers de
1 a n et les stocker en mmoire."
Le problme rside dans le choix de la structure d'accueil. Si on utilise un tableau, il n'est pas
possible de dfinir la taille de ce vecteur avec prcision mme si nous connaissons la valeur de n (par
exemple 10000). On est donc, ici, en face d'un problme o la rservation de l'espace doit tre dynamique.
Dfinition d'une liste linaire chane
Une liste linaire chane (LLC) est un ensemble de maillons (allous dynamiquement) chans
entre eux.
Schmatiquement, on peut la reprsenter comme suit :

Un lment d'une LLC est toujours une structure (Objet compos) avec deux champs : un champ
Valeur contenant l'information et un champ Adresse donnant l'adresse du prochain maillon. A chaque
maillon est associe une adresse. On introduit ainsi une nouvelle classe d'objet: le type POINTEUR qui est
une variable contenant ladresse dun emplacement mmoire.
Une LLC est caractrise par l'adresse de son premier lment appele souvent tte, premier ou
dbut.
NIL constitue l'adresse qui ne pointe aucun maillon par exemple le suivant du dernier maillon.

12


Reprsentation relle en mmoire
@ Valeur Pointeur
:
10 C 4300
12 F NIL
:
Tte= 4302
106 B 10
108 E 12
110 4302
:
4300 D 108
4302 A 106
4304
:
Schmatisation

A B
C
D E
F Nil
Tte

Modle sur les listes linaires chanes
Dans le langage algorithmique, on dfinira le type d'un maillon comme suit :
TYPE Tmaillon = STRUCTURE
Valeur: Typeqq { dsigne un type quelconque }
Suivant: POINTEUR(Tmaillon)
FIN
Afin de dvelopper des algorithmes sur les LLCs, on construit une machine abstraite avec les
oprations suivantes : Allouer, Librer, Aff_Adr, Aff_Val, Suivant, et Valeur dfinies comme suit :
Allouer(P) : allocation d'un espace de taille spcifie par le type de P. L'adresse de cet espace est rendue
dans la variable POINTEUR P.
Librer(P) : libration de l'espace point par P.

Valeur(P) : consultation du champ Valeur du maillon point par P.

Suivant(P) : consultation du champ Suivant du maillon point par P.

Aff_Adr(P, Q) : dans le champ Suivant du maillon point par P, on range l'adresse Q.

Aff_Val(P,Val) : dans le champ Valeur du maillon point par P, on range la valeur Val.
Cet ensemble est appel modle.
13

14
Algorithmes sur les listes linaires chanes
De mme que pour les tableaux, on peut classer les algorithmes sur les LLCs comme suit :
a) parcours : accs par valeur, accs par position,
b) mise jour : insertion, suppression, modification,
c) algorithmes sur plusieurs LLCs : fusion, interclassement, clatement,...
d) tri sur les LLCs.
1. Cration d'une liste et listage de ses lments
L'algorithme qui suit cre une liste linaire chane partir d'une suite de valeurs donnes, puis imprime la
liste ainsi cre.
ALGORITHME CrerListe
Valeur : Typeqq ; { dsigne un type quelconque }
Suivant : POINTEUR(Tmaillon) ;
FIN ;
VAR
P, Q, Tete : POINTEUR( Tmaillon) ;
I, Nombre : ENTIER ;
Val : Typeqq ;
DEBUT
Tete NIL ;
P NIL ;
LIRE(Nombre) ;
POUR I= 1 Nombre Faire
LIRE ( Val ) ;
Allouer ( Q ) ;
Aff_val(Q, val) ;
Aff_adr(Q, NIL) ;
SI Tete # NIL ALORS Aff_adr(P, Q)
SINON Tete Q ;
FSI
P Q ;
FINPOUR ;

{ Listage }
P Tete ;
TANTQUE P= NIL :
ECRIRE( Valeur( P) ) ;
P Suivant(P) ;
FINTANTQUE
FIN.
2. Recherche d'un lment
Il s'agit bien entendu de la recherche squentielle d'une valeur donne.
ALGORITHME Rechercher ;
Valeur : Typeqq ; { dsigne un type quelconque }
Suivant : POINTEUR(Tmaillon) ;
FIN ;
VAR

P, Tete : POINTEUR( Typedumaillon) ;
Trouv : BOOLEEN ;
Val : Typeqq ;
DEBUT
LIRE(Val) ;
P Tete ;
Trouv FAUX ;
TANTQUE P = NIL ET NON Trouv FAIRE
SI Valeur(P) = Val ALORS Trouv VRAI
SINON P Suivant(P) ;
FSI ;
FINTANTQUE ;
SI Trouv ALORS ECRIRE ( " L'lment existe " )
SINON ECRIRE ( " L'lment n'existe pas ") ;
FSI ;
FIN

Listes linaires chanes bidirectionnelles
Cest une LLC o chaque maillon contient la fois ladresse de son prdcesseur et de son successeur.

Nil
VAL
15

VAL

Dclaration
Type TMaillon=Structure
Val :TypeQuelconque ;
Suivant, Prcdent :Pointeur(TMaillon) ;
Fin;
Var Tete: Pointeur(TMailon) ;
Modle sur les listes linaires chanes bidirectionnelles
Allouer: Cration dun maillon.
Librer : Librer un maillon.
Valeur(P) : retourne la valeur du champ val du maillon point par P .
Suivant(P) : retourne le pointeur se trouvant dans le champs suivant du maillon point par P
Prcdent(P) : retourne le pointeur se trouvant dans le champs suivant du maillon point par P
Aff_Val(P,x) : Ranger la valeur de x dans le champs val du maillon point par P
Aff_Adr_Prcedent(P,Q) : Ranger Q dans le champs precedent du maillon point par P
Aff_Adr_Suivant(P,Q) : Ranger Q dans le champs suivant du maillon point par P
VAL VAL
Nil
Tete

2. Les piles (stacks)
Dfinition
Une pile est une liste ordonne dlments o les insertions et les suppressions dlments se font
une seule et mme extrmit de la liste appele le sommet de la pile
Le principe dajout et de retrait dans la pile sappelle LIFO (Last In First Out) le dernier qui entre est
le dernier qui sort

16

n

. .
. .

Utilisation des piles
- Appels rcursifs
Fact(4)=4*Fact(3)=4*3*Fact(2)=4*3*2*Fact(1)=4*3*2*1=4*3*2=4*6=24

- Parcours en profondeur des arbres

1
2*Fact(1) 2*Fact(1) 2
3*Fact(2) 3*Fact(2) 3*Fact(2) 3*Fact(2) 6
Fact(4) 4*Fact(3) 4*Fact(3) 4*Fact(3) 4*Fact(3) 4*Fact(3) 24
Pile des appels
a
b c
f
g
d
E
.
.
.
.
.
.
.
.

2
1
Base
Sommet
Dernier qui entre Premier qui sort
R
e
m
p
l
i
s
s
a
g
e


- Evaluation des expressions postfixes
Exemple : l'expression (( a + (b * c )) / (c d ) est exprime comme suit : bc*a+cd-/
Pour lvaluer, on utilise une pile
d

c a c c - d
b *

(c*b) + a+(c*b) - a+(c*b) / a+(c*b) / (c d)

Chaque fois : Lire ; si oprateur alors dpiler 2 fois puis calculer puis empiler ; sinon empiler
Oprations sur les piles
Les oprations habituelles sur les piles sont :
- Initialisation de la pile
- Vrification du contenu de la pile (pile pleine ou vide)
- Dpilement (POP) : retirer un lment du sommet de la pile si elle nest pas vide
- Empilement (PUSH) : ajout dun lment au sommet de la pile si elle nest pas sature.
Exemple
Donner ltat de la pile aprs lexcution des oprations suivantes sur une pile vide :
Empiler(a), Empiler(b), Dpiler, Empiler(c), Empiler(d), Dpiler, Empiler(e), Dpiler, Dpiler.
Reprsentation des piles
Les piles peuvent tre reprsents en deux manires :
- A laide des tableaux,
- A laide des listes linaires chanes.
1. Reprsentation par des tableaux.
Dclaration
Pile : Tableaux[1..n] de entier
Sommet : entier ;
Oprations de base :
Procedure init_Pile
Debut
17

18
Sommet 0;
Fin ;
Fonction Pile_Vide :Booleeen ;
Debut
Pile_Vide (Sommet=0) ;
Fin ;
Fin ;
Fonction Pile_Pleine :Booleeen ;
Debut
Pile_Pleine (Sommet=n) ;
Fin ;
Procedure Empiler (x :entier) ;
Debut
Si Sommet=n alors Ecrire(La pile est pleine)
Sinon
Sommet Sommet + 1 ;
Pile[Sommet] x ;
FSi
Fin ;
Procedure Dpiler (x :entier) ;
Debut
Si Sommet=0 alors Ecrire(La pile est vide)
Sinon
x Pile[Sommet];
Sommet Sommet - 1 ;
FSi

19
Fin ;

1. Reprsentation par des LLCs
Dclaration
Type TMaillon=structure
Valeur :TypeQuelconque ;
Suivant :Pointeur(TMaillon)
Fin ;
Pile : Pointeur(TMaillon) ;
Oprations de base :
Procedure init_Pile (Pile) ;
Debut
Pile Nil;
Fin ;
Fonction Pile_Vide(Pile) :Booleeen ;
Debut
Pile_Vide (Pile=Nil) ;
Fin ;
Fin ;
Procedure Empiler (Pile, x :entier) ;
Var P : Pointeur(TMaillon) ;
Debut
Allouer(P) ;
Aff_Val(P,x) ;
Aff_Adr(P,Pile) ;
Pile P ;
Fin ;


Procedure Dpiler (Pile, x :entier) ;
Debut
Si Pile=Nil alors Ecrire (Impossible, pile vide) ;
Sinon
X Valeur(P) ;
P Pile ;
Pile Suivant(Pile) ;
Liberer(P) ;
FSi
Fin ;
Exemple : Remplissage dune zone dune image
Une image en informatique peut tre reprsente par une matrice de points m ayant XMAX
colonnes et YMAX lignes. Un lment m[x,y] de la matrice reprsente la couleur du point p de
coordonnes (x;y). On propose d'crire ici une fonction qui, partir d'un point p, "tale" une couleur c
autour de ce point. La progression de la couleur tale s'arrte quand elle rencontre une couleur autre que
celle du point p. La figure suivante illustre cet exemple, en considrent p = (3;4).

L'ide ici est dempiler les coordonnes des diffrents points traits dans une pile, ensuite, itrativement,
tant que la pile n'est pas vide, on dpile un point du sommet de la pile et de le traiter et empiler ses voisins.

Procdure RemplirI(IMAGE i, POINT p, COULEUR c2):
Debut
c1 <- i[p.x,p.y];
Init_Pile;
Empiler(p);
TQ (non pile_Vide) faire
Depiler(p);
si (i[p.x,p.y] = c1) alors
i[p.x][p.y] <- c2;
si (p.x > 0) alors Empiler((p.x 1, p.y))
si (p.x < XMAX) alors Empiler((p.x + 1, p.y));
si (p.y > 0) alors Empiler ((p.x, p.y - 1));
si (p.y < YMAX) alors Empiler((p.x, p.y + 1));
fsi;
FTQ;
Fin;
20

3. Les Files dattente (Queues)
Dfinition
La file d'attente est une structure qui permet de stocker des objets dans un ordre donn et de les
retirer dans le mme ordre, c'est dire selon le protocole FIFO ("first in first out"). On ajoute toujours
un lment en queue de liste et on retire celui qui est en tte.

Tte Queue
Elment 1 Elment 2 . Elment n

Ajout Retrait

Utilisation des files dattente
Les files dattente sont utilises en programmation pour grer des objets qui sont en attente d'un
traitement ultrieur tel que la gestion des documents imprimer, des programmes excuter, des
messages reus,Elles sont utilises galement dans le parcours des arbres.
Oprations sur les files dattente
Les oprations habituelles sur les files sont :
- Initialisation de la file
- Vrification du contenu de la file (vide ou pleine)
- Enfilement : ajout dun lment la queue de la file
- Dfilement : retrait dun lment de la tte de la file
Implmentation des files dattente
De mme que pour les piles, les files dattente peuvent tre reprsentes en deux manires
- par reprsentation statique en utilisant les tableaux,
- par reprsentation dynamique en utilisant les listes linaires chanes.
Reprsentation statique
1.Par dcalage
Tte Queue

E1 E2 E3 E4 E5 E6 E7

21

Dfiler Queue

E2 E3 E4 E5 E6 E7

La file est vide si Queue = 0 ;
La file est pleine si Queue = n
Problme de dcalage chaque dfilement.
2. Par flot : La file est reprsente par un tableau circulaire

Tte Queue

22

E1 E2 E3 E4 E5 E6 E7

La file est vide si Tte = Queue ;
La file est pleine si (Queue + 1) mod n = Tete
On sacrifie toujours une case pour distinguer le cas dune file vide de celui dune file pleine.
Dclaration
File : Tableaux [1..n] de entier
Tete, Queue : entier ;
Oprations de base :
Procedure init_File
Debut
Tete 1;
Queue 1;
Fin ;
Fonction File_Vide :Booleeen ;
Debut
File_Vide (Tete=Queue) ;
Fin ;
Fin ;
Fonction File_Pleine :Booleeen ;
Debut

23
File_Pleine (((Queue+1) mod n)= Tete) ;
Fin ;
Procedure Enfiler (x :entier) ;
Debut
Si File_Pleine alors Ecrire(La file est pleine)
Sinon
File[Queue] x ;
Queue (Queue + 1) mod n ;
FSi
Fin ;
Procedure Dfiler (var x :entier) ;
Debut
Si File_Vide alors Ecrire(La file est vide)
Sinon
x File[Tete];
Tete (Tete+1) mod n ;
FSi
Fin ;
Reprsentation dynamique
La reprsentation dynamique utilise une liste linaire chane bidirectionnelle.
Dclaration
Type TMaillon=structure
Suivant, Precedent : Pointeur(TMaillon)
Fin ;
Tete, Queue : Pointeur(TMaillon) ;
Oprations de base :

24
Procedure init_File ;
Debut
Tete Nil;
Queue Nil;
Fin ;
Fonction File_Vide :Booleeen ;
Debut
File_Vide (Tete=Nil) ;
Fin ;
Fin ;
Procedure Enfiler (x : entier) ;
Var P : Pointeur(TMaillon) ;
Debut
Allouer(P) ;
Aff_Val(P,x) ;
Aff_Adr_Precedent(P,Queue) ;
Aff_Adr_Suivant(P,Nil) ;
Queue P ;
Si Tete=Nil alors
Tete P ;
FSi
Fin ;
Procedure Dfiler (var x :entier) ;
Debut
Si Tete=Nil alors Ecrire (Impossible, file vide) ;
Sinon
x Valeur(Tete) ;

25
P Tete ;
Tete Suivant(Tete) ;
Si Tete=Nil alors Queue Nil ;
Liberer(P) ;
FSi
Fin ;
File dattente particulire (File dattente avec priorit)
Une file d'attente avec priorit est une collection dans laquelle tout nouvel lment est insr
selon sa priorit et tout retrait se fait du dbut. Un lment prioritaire prendra la tte de la file mme
sil arrive le dernier.

IV. Structures hirarchiques
1. Les arbres
Introduction
Dans les tableaux nous avons :
+ Un accs direct par indice (rapide)
- Linsertion et la suppression ncessitent des dcalages
Dans les listes linaires chanes nous avons
+ Linsertion et la suppression se font uniquement par modification de chanage
- Accs squentiel lent
Les arbres reprsentent un compromis entre les deux :
+ Un accs relativement rapide un lment partir de sa cl
+ Ajout et suppression non coteuses
En plus plusieurs traitements en informatiques sont de nature arborescente tel que les arbres
gnalogiques, hirarchie des fonctions dans une entreprise, reprsentation des expressions
arithmtiques,.. etc.
Dfinitions
1. Dfinition dun arbre
Un arbre est une structure non linaire, cest un graphe sans cycle o chaque nud a au plus un
prdcesseur.
Graphe

26

Arbre
27

- Le prdcesseur sil existe sappelle pre (pre de C = A, pre de L = H)
- Le successeur sil existe sappelle fils (fils de A = {B,C,D}, fils de H= {L,M})
- Le nud qui na pas de prdcesseur sappelle racine (A)
- Le nud qui na pas de successeur sappelle feuille (E,F,G,L,J,)
- Descendants de (C={G,H,I,L,M}, B={E,F},)
- Ascendants de (L={H,C,A), E={B,A},)
2. Taille dun arbre
Cest le nombre de nuds quil possde .
Taille de larbre prcdent = 13
Un arbre vide est de taille gale 0.
3. Niveau dun nud
Le niveau de la racine = 0
Le niveau de chaque nud est gale au niveau de son pre plus 1
Niveau de E,F,G,H,I,J,K = 2
4. Profondeur (Hauteur) dun arbre
Cest le niveau maximum dans cet arbre.
Profondeur de larbre prcdent = 3
A
B C D
E G H J K F I
L M
Noeud
Pre
et
ses Fils
Sous-arbre
Nud racine
Niveau 0

Niveau 1

Niveau 2

Niveau 3

5. Degr dun nud
Le degr dun nud est gal au nombre de ses fils.
Dgr de (A = 3, B =2, C = 3, E= 0, H=2,)
6. Degr dun arbre
Cest le degr maximum de ses nuds.
Degr de larbre prcdent = 3.
Utilisation des arbre
1. Reprsentation des expressions arithmtiques
(A+B)*c (d+E*f)/6
-
28

2. Reprsentation dun arbre gnalogique
+
B A
*
F E
D
+ 6
/
Ibrahim
Ismail

Ishak

3. Codage
Exemple : coder la chaine "structure arbre"
Aissou Yakoub
Benyamin Youssef

Caractre Frquence Caractre Frquence
s 1 c 1
t 2 e 2
r 4 a 1
u 2 b 1


r
6
t
u
4
s c
2
a b
2
4
8
14
0
0
0
0
0
0
0
1
1
1
1
1
1
1
e

Caractre Code Caractre Code
s 0000 c 0001
t 010 e 001
r 11 a 100
u 011 b 101

Implmentation des arbres
Les arbres peuvent tre reprsents par des tableaux, des listes non linaires ou tous les
deux :
Reprsentation statique
Larbre du premier exemple peut tre reprsent par un tableau comme suit :
Num Information Fils 1 Fils 2 Fils 3
1 A 2 3 4
2 B 5 6 0
3 C 7 8 9
4 D 10 11 0
5 E 0 0 0
6 F 0 0 0
7 G 0 0 0
8 H 12 13 0
9 I 0 0 0
10 J 0 0 0
11 K 0 0 0
12 L 0 0 0
13 M 0 0 0

29



Information
Fils 1 Fils 2 Fils n
Information
Information
Information

Type TNoeud = Structure
Info : typeqq ;
Fils : Tableau[1..n] de Pointeur(TNoeud) ;
Fin ;
Var Racine :Pointeur(TNoeud) ;
Modle sur les arbres
Pour manipuler les structures de type arbre, on aura besoin des primitives suivantes :
Allouer (N) : crer une structure de type TNoeud et rendre son adresse dans N.
Liberer(N) : librer la zone pointe par N.
Aff_Val(N, Info) : Ranger la valeur de Info dans le champs info du nud point par N.
Aff_Fils
i
(N1,N2) : Rendre N2 le fils numro i de N1.
Fils
i
(N) : donne le fils numro i de N.
Valeur(N) : donne le contenu du champs info du nud point par N.
Traitements sur les arbres
1. Parcours des arbres :
Le parcours dun arbre consiste passer par tous ses nuds. Les parcours permettent
deffectuer tout un ensemble de traitement sur les arbres. On distingue deux types de parcours :
30


a. Parcours en profondeur
Dans un parcours en profondeur, on descend le plus profondment possible dans larbre puis,
une fois quune feuille a t atteinte, on remonte pour explorer les autres branches en commenant par
la branche la plus basse parmi celles non encore parcourues. Lalgorithme est le suivant :
Procedure PP(Nud)
Debut
Si Nud # Nil alors
Pour chaque filsi de Nud faire
PP(Fils
i
(Nud))
FPour
FSi
Fin ;
Le parcours en profondeur peut se faire en deux manire :
- Parcours en profondeur Prefixe : o on affiche le pre avant ses fils
- Parcours en profondeur Postfixe : o on affiche les fils avant leur pre.
Les algorithmes rcursifs correspondant sont les suivants :
Procedure PPPrefixe(Nud) Procedure PPPostfixe(Nud)
Debut
Si Nud # Nil alors
Pour i =1 n faire
PPPostfixe (Fils
i
(Nud))
FPour
Afficher(Valeur(Nud)) ;
FSi
Fin ;
Debut
Si Nud # Nil alors
Afficher(Valeur(Nud)) ;
Pour i =1 n faire
PPPrefixe (Fils
i
(Nud))
FPour
FSi
Fin ;
Le parcours en profondeur prfixe de larbre du premier exemple donne :
A,B,E,F,C,G,H,L,M,I,D,J,K
Tandisque le parcours en profondeur postfixe donne:
E,F,B,G,L,M,H,I,C,J,K,D,A
b. Parcours en largeur
Dans un parcours en largeur, tous les noeuds une profondeur i doivent avoir t visits
avant que le premier noeud la profondeur i + 1 ne soit visit. Un tel parcours ncessite que lon se
souvienne de lensemble des branches quil reste visiter. Pour ce faire, on utilise une file dattente.

31

32
Procedure PL(Nud) ;
Var N :Pointeur (TNoeud) ;
Debut
Si Nud # Nil alors
Enfiler(Nud) ;
TantQue Non(FileVide) Faire
Dfiler(N) ;
Afficher(Valeur(N)) ;
Pour i = 1 n Faire
Si Filsi(N) # Nil alors
Enfiler( Filsi(N)) ;
Fsi
FPour
FTanque ;
Fsi
Fin ;
Lapplication de cet algorithme sur larbre du premier exemple donne
A,B,C,D,E,F,G,H,I,J,K,L,M
2. Recherche dun lment
Fonction Rechercher(Nud, Val) :Booleen ;
Var i :Entier ; Trouv :Booleen ;
Debut
Si Nud=Nil alors Rechercher Faux ;
Sinon
Si Valeur(Nud)=Val alors Rechercher Vrai
Sinon
i 1 ; Trouv Faux ;
TantQue i s n et non Trouv Faire
Trouv Rechercher(Fils
i
(Nud), Val) ;
i i + 1 ;
FTQ
Rechercher Trouv ;
FSi
FSi
Fin ;
2. Calcul de la taille dun arbre
Fonction Taille(Nud) : entier ;
Var i, S : entier ;
Debut
Si Noeud = Nil alors Taill 0
Sinon
S 1 ;
Pour i = 1 n faire
S S + Taille(Fils
i
(Nud)) ;
FPour
Taille S ;
FSi ;
Fin ;

33
Typologie des arbres
Arbre m-aire un arbre m-aire dordre n est un arbre ou le degr maximum dun nud est gal n.
B-Arbre : Un arbre B d'ordre n est un arbre o :
- la racine a au moins 2 fils
- chaque nud, autre que la racine, a entre n/2 et n fils
- tous les nuds feuilles sont au mme niveau
Arbre binaire: cest un arbre ou le degr maximum dun noeud est gal 2.
Arbre binaire de recherche : cest un arbre binaire o la cl de chaque nud est suprieure celles
de ses descendants gauche, et infrieure celles de ses descendants droits.

Algo 1, 2LMD, Infor
2. Les arbres binaires de recherche
Dfintion
Les arbres binaires de recherche sont utiliss pour acclrer la recherche dans les arbres m-aires.
Un arbre binaire de recherche est un arbre binaire vrifiant la proprit suivante : soient x et y deux
nuds de larbre, si y est un nud du sous-arbre gauche de x, alors cl (y) s cl (x), si y est un nud
du sous-arbre droit de x, alors cl(y) > cl (x).

Un nud a, donc, au maximum un fils gauche et un fils droit.
Implmentation des ABR
Les arbres de recherche binaires sont implments de la mme manire que celles m-aires
(statique ou dynamique)
Reprsentation Statique
Num Information Fils gauche Fils droit
1 15 2 3
2 6 4 5
3 18 6 7
4 3 8 9
5 7 0 10
6 17 0 0
7 20 0 0
8 2 0 0
9 4 0 0
10 13 11 0
11 9 0 0
Cl + Info

FG FD
matique
34

Cl + Info
Cl + Info
FG FD
FG FD
Cl + Info
FG FD
Cl + Info
FG FD
Cl + Info
FG FD

.
.

.

35
Type TNoeud = Structure
Cl,Info : typeqq ;
FG, FD : Pointeur(TNoeud) ;
Fin ;
Var Racine :Pointeur(TNoeud) ;
Modle sur les ABR
Allouer (N) : crer une structure de type TNoeud et rendre son adresse dans N.
Liberer(N) : librer la zone pointe par N.
Aff_Val(N, Info) : Ranger la valeur de Info dans le champs info du nud point par N.
Aff_Cl(N, Cl) : Ranger la valeur de Cl dans le champs Cl du nud point par N.
Aff_FG(N1,N2) : Rendre N2 le fils gauche de N1.
Aff_FD(N1,N2) : Rendre N2 le fils droit de N1.
FG(N) : donne le fils gauche de N.
FD(N) : donne le fils droit de N.
Valeur(N) : donne le contenu du champs info du nud point par N.
Cl(N) : donne le contenu du champs Cl du nud point par N.
Traitements sur les ABR
1. Parcours
De mme que pour les arbres m-aires, le parcours des ARB peut se faire en
profondeur ou en largeur :
a. En profondeur
Procedure PP(Nud)
Debut
Si Nud # Nil alors
PP(FG(Nud)) ;
PP(FD(Nud)) ;
FSi
Fin ;
Le listage des lments de larbre en profondeur peut se faire en :
- prfix (prordre) : Pre FG FD,
- infix (inordre) : FG Pre FD,
- postfix (postordre) : FG FD Pre.


Procedure PPPrtfix(N:Pointeur(TNoeud)) Procedure PPInfix(N:Pointeur(TNoeud))
Debut
36

b. En largeur
Procedure PL(Racine : Pointeur(TNoeud) ) ;
Debut
Init_File ;
Si Racine # Nil alors
Enfiler(Racine) ;
TantQue Non(FileVide) Faire
Dfiler(N) ;
Si FG(N) # Nil alors Enfiler( FG(N)) Fsi ;
Si FD(N) # Nil alors Enfiler( FD(N)) Fsi ;
FTanque ;
Fsi
Fin ;
Trace : 15 6 18 3 7 17 20 2 4 13 9
2. Recherche
Fonction Rechercher (Racine : Pointeur(TNoeud) ; xCl :Typeqq) : Pointeur(TNoeud)
Debut
Si Racine = Nil ou Cl(Racine) = xCl Alors Rechercher Racine
Sinon
Si Cl(Racine) > xCl Alors Rechercher Rechercher(FG(Racine), xCl)
Sinon Rechercher Rechercher(FD(Racine), xCl)
FSi
FSi
Fin ;
3. Insertion
Llment ajouter est insr l o on laurait trouv sil avait t prsent dans larbre.
Lalgorithme dinsertion recherche donc llment dans larbre et, quand il aboutit la
conclusion que llment nappartient pas larbre (lalgorithme aboutit sur NIL), il insre
llment comme fils du dernier nud visit.
Debut
Si N # Nil alors Si N # Nil alors
Afficher(Valeur(N)) ; PPInfix (FG(N)) ;
PPPrefixe (FG(N)) ; Afficher(Valeur(N)) ;
PPInfix (FD(N)) ; PPPrefixe (FD(N)) ;
FSi
Fin ;
Trace : 15 6 3 2 4 7 13 9 18 17 20
FSi
Fin ;
Trace : 2 3 4 6 7 9 13 15 17 18 20
Procedure PPostfix(N:Pointeur(TNoeud))
Debut
Si N # Nil alors
PPPostfixe (FG(N)) ;
PPPostfixe (FD(N)) ;
FSi
Fin ;
Trace : 2 4 3 9 13 7 6 17 20 18 15

4. Suppression
Plusieurs cas de figure peuvent tre trouvs : soit supprimer le nud N
Cas
FG(N) FD(N) Exemple
Action
Nil Nil Feuille (2,4,17) Remplacer n par Nil
Nil # Nil 7 Remplacer N par FD(N)
# Nil Nil 13 Remplacer N par FG(N)
# Nil # Nil 6
Rechercher le plus petit descendant droit de
N soit P (7),
Remplacer Info(N) par Info (P) (6 7)
Remplacer P par FD (P) (7 13 )
Exercice : Donner larbre aprs la suppression de 3 puis de 15.
3. Equilibrage
Soit les deux ARB suivants :
37

Ces deux ARB contiennent les mmes lments, mais sont organiss diffremment. La profondeur
du premier est infrieure celle du deuxime. Si on cherche llment 10 on devra parcourir 3
lments (50, 20, 10) dans le premier arbre, par contre dans le deuxime, on devra parcourir 5 lment
(80, 70, 50, 20,10). On dit que le premier arbre est plus quilibr.
Si on calcule la complexit de lalgorithme de recherche dans un arbre de recherche binaire, on va
trouver O(h) ou h est la hauteur de larbre. Donc plus larbre est quilibr, moins leve est la hauteur
et plus rapide est la recherche.
On dit quun ARB est quilibr si pour tout nud de larbre la diffrence entre la hauteur du sous-
arbre gauche et du sous-arbre droit est dau plus gal 1.
Il est conseill toujours de travailler sur un arbre quilibr pour garantir une recherche la plus
rapide possible. Lopration dquilibrage peut tre faite :
- chaque fois quon insre un nouveau nud,
- chaque fois que le dsquilibre atteint un certain seuil pour viter le cot de lopration
dquilibrage qui ncessite une rorganisation de larbre.

50
20 80
70 40 10
50
20
80
70
40 10

3. Les tas
Introduction
Pour implmenter une file dattente avec priorit, souvent utilise dans les systmes dexploitation
pour la gestion des programmes en cours dexcution, on peut utiliser :
- Une file dattente ordinaire (sans priorit), linsertion sera alors simple ( la fin) en O(1), mais le
retrait ncessitera la recherche de llment le plus prioritaire, en O(n).
- Un tableau (ou une liste) tri o le retrait sera en O(1) (le premier lment), mais linsertions
ncessitera O(n).
Les tas apportent la solution ce problme.
Dfinition
Un tas (heap en anglais) est un arbre qui vrifie les deux proprits suivantes :
1. Cest un arbre binaire complet c'est--dire un arbre binaire dont tous les niveaux sont remplis
sauf ventuellement le dernier o les lments sont rangs le plus gauche possible.
2. La cl de tout nud est suprieure celle de ses descendants.
Exemple dun tas :

Oprations sur les tas
Pour coder une file dattente avec priorit par un tas, on doit dfinir les oprations dinsertion et de
retrait :
1. Insertion
Pour insrer un nouvel lment dans la file avec priorit c--d dans le tas on doit :
1. crer un nud contenant la valeur de cet lment,
2. attacher ce nud dans le dernier niveau dans la premire place vide le plus gauche possible
(crer un nouveau niveau si ncessaire). On obtient toujours un arbre binaire complet mais
pas ncessairement un tas.
3. comparer la cl du nouveau nud avec celle de son pre et les permuter si ncessaire, et
recommencer le processus jusquil ny ait plus dlments permuter.
38

Exemple : soit insrer llment de priorit 15 :

- 1 -

La complexit de cette opration est de O(h = Log2(n)) si n est le nombre dlments.
2. Retrait
Llment le plus prioritaire se trouve toujours la racine, donc le retrait consiste lire la racine
puis la supprimer. Pour ce faire on doit :
1. remplacer la valeur de la racine par la valeur du llment le plus droite dans le dernier
niveau.
2. supprimer de larbre cet lment (le plus droite dans le dernier niveau), on obtient un
arbre binaire mais pas ncessairement un tas.
3. On compare la valeur de la racine avec les valeurs de ses deux fils et on la permute avec
la plus grande. On recommence le processus jusquil ny ait plus dlments permuter.
Exemple :
39

- 2 -

- 3 -

- 1 -

- 2 -


- 3 -

- 4 -
La suppression est aussi en O(h = Log
2
(n)).
Implmentation des tas :
Les tas peuvent tre implments dynamiquement exactement comme les ARB, et sont utiliss par
le mme modle.
Une reprsentation statique trs fficace utilisant das tableaux est trs utilise en pratique, elle
consiste ranger les lments du tas dans un tableau selon un parcours en largeur :

40

1 2 3 4 5 6 7 8 9 10
16 14 10 8 7 9 3 2 4 1
On remarque su le tableau obtenu que le fils gauche dun lement dindice i se trouve toujours
sil existe la position 2i, et son fils droit se trouve la position (2i + 1) et son pre se trouve la
position i/2.
Avec ce principe les oprations dajout et de retrait se font dune manire trs simple et
extrmement efficace.

41
V. Structures en tables
Introduction
On utilise souvent en informatique une structure appele Table ou dictionnaire pour ranger des
informations en mmoire.
Une table est un ensemble de couples <cl, information> o chaque cl napparat quune seule
fois dans la table.
Exemples :
1. Annuaire tlphonique
Cl (Nom) Information (Tl + Adresse)
SAMIR 033701520 Sidi Okba
FARID 072171304 Eloued
.
.
.
.
.
.
.
.
.
2. Dictionnaire
Cl (Mot) Information (Signification)
Arbre Graphe connexe sans cycle
Table Ensemble de couples <cl, info>
.
.
.
.
.
.
3. Codage
Cl (Caractre) Information (Code)
a 001
b 010
.
.
.
.
.
.

Le problme pos est : comment organiser la table pour que les accs (recherche, insertion,
suppression) soient les plus rapides possibles ?


1. Accs squentiel
Il consiste ranger les cls dans la table dans lordre de leur arrive, les une la suite des autres,
c'est--dire que lajout se fait toujours la fin de la table.
La recherche dune cl consiste tester les lments lun aprs lautre jusqu le trouver c'est--
dire passer par tous les lments placs avant. La recherche est alors en moyenne de n/2 (O(n)).
2. Table trie
La table est trie selon les valeurs des cls : la recherche est en log
2
(n) c--d dichotomique.
3. Hachage (HashCoding)
Principe :
Cest une technique trs utilise en informatique, elle se base sur une fonction h appele fonction
de hachage ou de hashcoding, qui applique la cl fournit lindice correspondant dans la table.
Cl Information

42
0

.
.
.
.

.
.
.
.

Cl
h(Cl) = i
i
N-1
Exemple : Codage
Cl = Caractre (A, B, ) N = 10 h: Code ASCII mod N
Cl Information
F 001
1
2
3 S 010
4
5
6
7 C 110
8
9
0
h(S) =83 mod 10 =3
h(C) =67 mod 10 =7
h(F) =70 mod 10 =0

Fonctions de Hachage :
On trouve plusieurs types de fonctions utilises en Hashcoding :
1. h(cl) = CodeASCII ( 1
er
car) + Code ASCII(2eme car) mod N
Si la cl est une chaine de caractres (nom)
2. h(cl) = cl mod N
Si cl est une valeur numrique.
3. Mthode du milieu du carr
Cl = 453 (Cl)
2
= (453)
2
= 205209
h(453) = 52.
Si n > 100, on prend 3 chiffres.
4. Hachage de fibonacci
Cest une fonction de hachage frquemment utilise :

( ) r cl r cl N cl h * * ) ( =

o | | donne la partie entire.
Avec
2
1 5
= r
La fonction de hachage doit donner des valeurs entires dans lintervalle des indices de
la tables :
N cl h s s ) ( 1
En plus, cette fonction doit tre lka plus distribue possible sur cette intervalle pour que
les informations ne se concentrent pas dans une partie de la table.
Problme de collisions
Un problme srieux se pose avec les fonctions de hachage si deux cls diffrentes donnent lieu
une mme adresse lorsquon leur applique la fonction de hachage c--d h(cl
1
) = h(cl
2
). Une telle
situation est appele collision et plusieurs solutions existent pour sa rsolution.
1. Les listes linaires chanes.
Elle consiste placer toutes les cls qui donnent le mme indice quune cl existante dans une liste
linaire chaine, appele liste de dbordement:
43


Cl Info Suiv
0 F 001 Nil
44
1
2
3 S 010 Nil
4
5
6
h(S) =83 mod 10 =3
h(C) =67 mod 10 =7
7
h(F) =70 mod 10 =0
h(M) =77 mod 10 =7
C 110
M 011 W 000 Nil
h(W) =87 mod 10 =7
8
9

2. Essai linaire (adressage ouvert)
On range la cl qui a caus la collision (k par exemple) dans la premire position vide dans la
squence cyclique :
h(k-1), h(k-2), , 0, N-1, N-2, h(k+1)
Exemple :

Cl Info
0 F 001
1
2
3 S 010
4
5 W 000
6 M 011
7 C 110
8
9 P 111
h(S) =83 mod 10 =3
h(C) =67 mod 10 =7
h(F) =70 mod 10 =0
h(M) =77 mod 10

=7
h(W) =87 mod 10 =7

h(P) =80 mod 10 =0

On doit garder, dans ce cas, une case toujours vide por indiquer la fin de la recherche, c--d une
valeur interdite dans les cls.
3. Chanage interne spar
On ajoute la table une partie rserve aux collisions de taille M. La taille de la table sera donc
N+M.
On insre llment en collision dans la premire place vide dans la partie des collisions et on le
relie par un chanage.

Exemple :
Cl Info Suiv
0 F 001 10
1
2
3 S 010 -1
4
5
6
7 C 110 11
8
9
10 P 111 -1
11 M 011 12
12 W
45
000 -1
13
14

h(S) =83 mod 10 =3
h(C) =67 mod 10 =7
h(F) =70 mod 10 =0
h(M) =77 mod 10 =7
h(W) =87 mod 10 =7
h(P) =80 mod 10 =0
Partie des
collisions

VI. Les Graphes
Introduction
La notion de graphe est une structure qui permet de reprsenter plusieurs situations relles, en
but de leur apporter des solutions mathmatiques et informatique, tel que :
- Les rseaux de transport (routiers, ferrs, ariens),
- Les rseaux tlphoniques, lectriques, de gaz,etc,
- Les rseaux dordinateurs,
- Ordonnancement des tches,
- Circuits lectroniques,
-
Les arbres et les listes linaires chanes ne sont que des cas particuliers des graphes.
1. Dfinitions
Graphe : un graphe est dfini par un couple (S, A) o S est un ensemble de sommets (nuds ou
points) et A est un sous ensemble du produit cartsien (S X S) reprsentant les relations existant entre
les sommets.
Exemple :
S = {1, 2, 3, 4, 5, 6, 7} A = {(1,2), (1,4), (2,5) (3,5), (3,6), (4,2), (5,4), (6,6)}
46

1 2 3
4 5 7 6
Sommet
Arc

Graphe orient : Cest un graphe o les relations entre les sommets sont dfinies dans un seul
sens (exemple prcdent). Dans ce cas les relations sont appeles arcs .
Graphe non orient : Cest un graphe o les relations sont dfinies dans les deux sens. Dans ce
cas les relations sont appeles artes .
1 2 3
4 5
arte

Graphe tiquet ou pondr : Cest un graphe orient ou non o chaque arc ou arte correspond
une valeur ou une tiquette reprsentant son cot (ou distance).


47

Si a = (x, y) est un arc de x vers y alors :
x est lorigine de a et y est son extrmit
x est un prdcesseur de y et y est un successeur de x
Si lorigine est lextrmit dun arc se concident on lappelle une boucle (6,6).
Un chemin : est un ensemble darc a
1
, a
2
, ,a
p
o
Origine(a
i+1
) = Extrmit(a
i
) 1 s i < p
On dit que le chemin est de longueur P-1
Exemple : {(1,2), (2,5), (5,4)}
Un circuit : est un chemin a
1
, a
2
, ,a
p
o Origine(a
1
) = Extrmit(a
p
)
Exemple : {(2,5), (5,4), (4,2)}
Une chane : est un chemin non orient.
Exemple : {(1,4),(5,4),(3,5)}
Un cycle : est une chane ferme.
Exemple : {(1,2),(2,5),(5,4),(1,4)}
Un graphe connexe est un graphe o pour tout couple de sommets (x, y), il existe une chane
darcs les joignant.
Exemple : pour (1,6), il existe une chane darcs, et il nen existe pas pour (1,7).
Un graphe fortement connexe est un graphe o pour tout couple de sommets (x, y), il existe un
chemin darcs les joignant.
Exemple : pour (3,2) il existe un chemin {(3,5), (5,4), (4,2)} mais il nen existe pas pour
(2,3).

2. Reprsentation
Etiquette =200
1 2 3
4 5 7 6
10
125
12
96
22
3
17

Les graphes peuvent tre reprsents en deux manires : en listes dadjacence (dynamique) ou en
matrice dadjacence (statique)
Listes dadjacence :
Dans cette reprsentation, les successeurs dun nud sont rangs dans une liste linaire chane.
Le graphe est reprsent par un tableau T o T[i] contient la tte de la liste des successeurs de i. Le
graphe (S,A) prsent au dbut de cette section peut tre reprsent comme suit:

4 Nil

48

Les listes dadjacence sont tries par numro de sommet, mais les successeurs peuvent apparatre
dans nimporte quel ordre.
Type Tmaillon = Structure
Successeur :entier ;
Suivant : Pointeur(TMaillon) ;
Fin ;
Graphe : Tableau[1..n] de Pointeur(TMaillon) ;
Matrice dadjacence :
Dans cette reprsentation le graphe est stock dans un tableau deux dimensions de valeur
boolennes ou binaires. Chaque case (x,y) du tableau est gale vrai (1) sil existe un arc de x vers y,
et faux (0) sinon. Dans la matrice suivante, on reprsente le graphe prcdent (1 pour vari et 0 pour
faux):

Il est clair que la matrice dadjacence dun graphe non orient est symtrique puisque chaque
arte existe dans les deux sens.
Graphe : Tableau[1..n,1..n] de boolen ;
Pour un graphe tiquet les valeurs de la matrice peuvent tre les tiquettes elles-mmes, avec
une valeur particulire pour les arcs inexistant. Par exemple le graphe tiquet de lexemple peut tre
reprsent comme suit :

1

2

3

4

5

6

7
Nil
2
5 Nil
6 Nil 5
2 Nil
4 Nil
6 Nil
1 2 3 4 5 6 7
0 1 0 1 0 0 0 1
0 0 0 0 1 0 0 2
0 0 0 0 1 1 0 3
0 1 0 0 0 0 0 4
0 0 0 1 0 0 0 5
0 0 0 0 0 1 0 6
0 0 0 0 0 0 0 7
1 2 3 4 5 6 7
-1 10 -1 200 -1 -1 -1 1
-1 -1 -1 -1 125 -1 -1 2
-1 -1 -1 -1 22 17 -1 3
4 -1 96 -1 -1 -1 -1 -1
5 -1 -1 -1 12 -1 -1 -1
1 1 1 1 1 3 1

49

La reprsentation matricielle permet de tirer des conclusions intressantes sur les graphes en
utilisant les calculs matriciels.
3. Parcours de graphes
De mme que pour les arbres, il est important de pouvoir parcourir un graphe selon
certaines rgles, cependant, le parcours des graphe est un peut diffrent de celui des arbres. Dans un
arbre, si on commence partir de la racine on peut atteindre tous les nuds, malheureusement, ce
nest pas le cas pour un graphe o on est oblig de reprendre le parcours tant quil y a des sommets
non visits. En plus un graphe peut contenir des cycles, ce qui conduit des boucles infinies de
parcours. Il existe deux types de parcours de graphes : le parcours en profondeur dabord (Depth First
Search) et le parcours en largeur dabord (Breadth First Search).
En profondeur dabord (DFS) :
Le principe du DFS est de visiter tous les sommets en allant le plus profondment possible dans
le graphe.
Graphe : tableau[1..n, 1..n] de booleen ;
Visit : tableau[1..n] de booleen initialis faux;

Procedure DFS(sommet :entier)
Var i : entier ;
Debut
Visit[sommet] vrai ;
Afficher (sommet) ;
Pour i = 1 n faire
Si Graphe[sommet,i] et non Visit[i] alors
DFS(i) ;
FSi
FPour
Fin ;
Appel
Pour s = 1 n faire
Si non Visit[s] alors
DFS(s)
FSi
FPour
Trace : 1 2 5 4 3 6 7
La procdure DFS peut tre utilise pour divers objectifs :
- Pour vrifier sil existe une chemin dun sommet s
1
vers un autre s
2
en initialisant le tableaux
Visit faux et en appelant DFS(s
1
) pour ce sommet. Si Visit[s
2
] est vrai la fin de
lappel de DFS, alors un chemin existe entre s
1
et s
2
.

- Pour vrifier si un circuit contentent deux sommets s
1
et s
2
existe, en appelant DFS(s
1
) pour
un tableaux Visit
1
et DFS(s
2
) pour un tableaux Visit
2
, si Visit
1
[s
2
] et Visit
2
[s
1
] sont
vrai aprs lappel alors un tel circuit existe.
- De la mme manire pour vrifier si un graphe est cyclique (contient des circuits) ou non.
- Pour trouver les chemins minimums dun sommet s vers tous les autres.
En largeur dabord (BFS)
Dans ce parcours, on un sommet s est fix comme origine et lon visite tous les sommet situs
une distance k de s avant de passer ceux situs k+1. On utilise pour cela une file dattente.
Procedure BFS(s : sommet)
Debut
Enfiler(s) ;
Tantque non File_Vide faire
Defiler(s1) ;
Afficher(s1) ;
Pour i = 1 n faire
Si Graphe[s,i] et non Visit[i] alors
Enfiler(i) ;
FSi
FPour
FTQ
Fin ;
Appel
Pour s = 1 n faire
Si non Visit[s] alors
BFS(s)
FSi
FPour
Trace : 1 2 4 5 3 6 7
4. Plus court chemin (algorithme de Dijkstra)
Soit un graphe G (S,U) orient sans boucles avec n sommets,
(x
i
,x
j
) e U l
ij
= longueur de larc (x
i
,x
j
)
La longueur dun chemin =
e ) (
j i
x x
ij
l

On peut trouver plusieurs chemins reliant un sommet un autre. Le problme du chemin
minimum ou de plus court chemin consiste trouver le chemin de moindre cot.
On trouve plusieurs algorithmes pour la rsolution de ce problme : Dijkstra, Ford, Belman-
Kalaba,
50

Algorithme de Dijkstra
Lalgorithme de Dijkstra rsout le problme de la recherche dun plus court chemin origine
unique pour un graphe orient pondr G = (S, U) dans le cas o tous les arcs ont un poids positif ou
nul.
Lalgorithme de Dijkstra maintient jour un ensemble D des sommets de S dont le plus court
chemin partir de lorigine s est connu et calcul. chaque itration, lalgorithme choisit parmi les
sommets de (S D) cest--dire parmi les sommets dont le plus court chemin partir de lorigine nest
pas connu, le sommet x dont lestimation de plus court chemin est minimale. Une fois un sommet u
choisi, lalgorithme met jour, si besoin est, les estimations des plus courts chemins de ses
successeurs (les sommets qui peuvent tre atteint directement partir de u).
Algorithme
1- D = {x
i
},
i
= 0 // x
i
sommet de dpart

j
= l
ij
j = i (si un arc (x
i
,x
j
) nexiste pas l
ij
= +
//
j
cot du chemin minimum entre x
i
et x
j

2-
k
= min
j
x
j
eD
3- D = D {x
k
}

j
= min {
j
,
k
+ l
kj
}
4- Aller 2 si D = S
Exemple :
51

D
1

2

3

4

5

6

x
1
0 3 8 6
x
1,
x
2
0 3 8 5 9
x
1,
x
2,
x
4
0 3 7 5 9 12
x
1,
x
2,
x
4,
x
3
0 3 7 5 8 12
x
1,
x
2,
x
4,
x
3,
x
5
0 3 7 5 8 10
x
1,
x
2,
x
4,
x
3,
x
5,
x
6
0 3 7 5 8 10

x
1

x
2

x
3

x
4

x
5

2
7
3
6 6
x
6

2
8
2
1

52
VII. Preuve dalgorithmes
La preuve dun algorithme consiste montrer quil transforme bien ses entres en les sorties
attendues, autrement dit, tout tat initial de lalgorithme conduit en sortie un tat final qui vrifie une
certaine proprit (ex: factorielle = n!).
La mthode usuelle pour vrifier quun algorithme P, devant calculer la fonction f, est correct est la
mthode des tests : on choisit un chantillon fini de donnes d1, , dn, on fait excuter lalgorithme P
pour chacune dentre elles et on vrifie que :
P(d1) = f(d1), , P(dn) = f(dn).
Cest--dire dmontrer un thorme quivalent :
d e D, P(d) = f(d).
Linsuffisance de cette mthode est vidente ds que lchantillon test ne recouvre pas lensemble
D des donnes.
La mthode des preuves dalgorithme est bien plus satisfaisante : elle consiste prouver
mathmatiquement que lalgorithme P est correct en dmontrant quil:
- termine (terminaison), et
- calcule bien sa fonction f (correction partielle)
On distingue donc trois notions : terminaison, correction partielle et correction totale :
Correction totale = Correction partielle + Terminaison
1. Terminaison
On dit quun algorithme P termine si et seulement si tout tat initial E donne une excution
terminante de P.
2. Correction partielle
Soit lalgorithme P dont la correction est exprime par une condition C, On dit que P est
partiellement correct si et seulement si, pour tout tat initial E qui donne une excution terminante
F=P(E) on a F(C) = Vrai.

3. Correction totale
On dit que P est totalement correct si et seulement si tout tat initial E donne une excution
terminante F=P(E) qui vrifie F(C)=Vrai.
Exemples :
1. Lalgorithme suivant ne termine pas :
Tantque V faire

53
Fintq
2. Etant donn la proprit C=(r = max(x,y)),
Lalgorithme suivant nest pas partiellement correct parce quil ne vrifie pas C pour des
cas dexcutions terminantes (x>y , r= ?).
si x<y alors
ry
finsi
Lalgorithme suivant est partiellement correct et termine; il est donc totalement correct
si x<y alors
ry
sinon
rx
finsi
Lalgorithme suivant est partiellement correct mais ne termine pas (toujours); il nest donc
pas totalement correct
si x<y alors ry
sinon
tantque x<>y faire
rx
fintq
finsi

4. Outils de preuve dalgorithme (Logique de Hoare)
Pour vrifier la correction totale dun algorithme, on doit vrifier quil est partiellement correct et
quil se termine. Pour cela on utilise la logique de Hoare qui reprsente un systme dductif propos par
Tony Hoare qui permette de vrifier si un algorithme vrifie ncessairement une proprit la fin de
toutes ses excutions
Dans la logique de Hoare, la preuve dun algorithme P est reprsente par un triplet appel triplet de
Hoare :
{c} P {c}

54
O
{c} : est une expression boolenne appele la prcondition
P : lalgorithme (le programme)
{c} : est une expression boolenne appele la postcondition.
Ce triplet est interprt comme suit :
Si les variables de "P" vrifient initialement la condition "c" alors, si "P" se termine, les variables
vrifieront le condition c aprs lexcution de P
Exemple
Soit lalgorithme suivant :
Algorithme Div ;
Var a,b,r,q :entier ;
Debut
Lire(a,b) ;
r a ;
q 0 ;
Tantque r>=b faire
r r b ;
q q + 1 ;
FinTq
Ecrire(q, r) ;
Fin.
Le triplet de Hoare utilis dans la preuve de cet algorithme est le suivant :
{a>=0 & b>0} Div {a=b*q + r & r<b}
La preuve consiste dmonter que ce triplet soit valide en utilisant un axiome et six rgles :
1. Axiome de laffectation
{x=y} x 2 * x {x=2 * y}
2. Rgle de la squence

55
Si [{c} P1 {c1} et {c1} P2 {c}] alors [{c} P1 ; P2 {c}]
3. Rgle de la conditionnelle
Si [{c & b} P1 {c} et {c & non b} P2 {c}] alors [{c} Si b Alors P1 Sinon P2 Fsi {c}]
4. Rgle de la rptitive
Si [{c & b} P {c}] alors [{c} Tantque b Faire P FinTq {c & non b}]
5. Rgle de consquence
Si [c1 => c2 et {c2} P {c3} et c3 => c4] alors [{c1} P {c4}]
6. Rgle de la conjonction
Si [{c} P {c1} et {c} P {c2}] alors [{c} P {c1 et c2}]
7. Rgle de la disjonction
Si [{c1} P {c} et {c2}] P {c} alors [{c1 ou c2} P {c}]
On utilise ces rgles pour construire lalgorithme propos en remontant partir de la postcondition
pour arriver la prcondition. Si lalgorithme a pu tre construit, on dit que lalgorithme est partiellement
correct.
Pour dmonter la terminaison de lalgorithme, il faut dmontrer que toutes ses boucles se terminent,
pour cela, il faut dmonter que lexpression de la condition de chaque boucle forme une suite convergente.
Cette dmonstration peut tre faite par la logique de Hoare comme suit :
{Condition de la boucle} Boucle { Condition de la boucle}
Conclusion
La preuve dun algorithme - mme petit est une opration trs longue et fastidieuse, mme si
lapplication des rgles est mcanique, linvention de la prcondition et la postcondition nest pas vidente
et difficilement automatisable.
Malgr tout le preuve formelle de hoare reste le seul moyen de preuve des algorithmes.

56
VIII. Exercices avec et sans solutions

1. Complexit algorithmique
1. Calculer la complexit de lalgorithme suivant
Pour i=2 n faire
ki-1 ;
xT[i]
Tantque T[k]>x et k>0 Faire
T[k+1] T[k] ;
kk-1
FTq
T[k+1] x
FPour

2. Calculer la complexit de l'algorithme suivant :
i n;
S 0;
Tantque i>0 Faire
j 2*i;
Tantque j > 1 Faire
S S+(j-i)* (S+1) ;
j j-1
FTQ;
i i div 2
FTQ;

3. Calculer la complexit de l'algorithme suivant:
i1;
j0;
Pour k1,n Faire
j i+j;
i j-i;
Fpour;
Que fait cet algorithme sachant que le rsultat est dans j ?

4. Calculer la complexit de la fonction suivante :

Fonction Fib(n:entier):entier
Debut
Si n < 2 alors
Fib 1;
Sinon
Fib Fib(n - 1)+Fib(n - 2)
Fsi
Fin

5. Calculer la complexit de l'algorithme suivant :

57

P 1 ;
Pour I = 1 , n Faire
J 1 ; K 1 ;
Tantque K s n
P P * (K + J) ; K K + 1 ;
SI K > n alors
J J + 1 ;
SI J s n alors K 1 FSI
FSI
FTQ
FPour
6. Trouver la complexit de lalgorithme suivant:
i 1 ;
Tantque i < n Faire
j 1 ;
Tantque j < 2*n Faire
j j*2 ;
FTQ
i i+1 ;
FTQ
7. Trouver la complexit de la fonction suivante:
Fonction f ( i, j, k :entier) : entier
var x : entier
Debut
SI k+j = i alors
f ((i-j) div k) + 1 ;
SINON
x f(i, j+1, k-2) ;
f f(i+1, j+x, k-2) ;
FSI
Fin;
8. Trouver la complexit du programme suivant :
i 1 ; j 1 ;
Tantque i < n Faire
SI j < n alors
j j * 2
SINON
j 1 ; i i + 1
FSI
FTQ
9. Calculer la complexit de la procdure rcursive F(x, y, z) suivante :
Procedure F(x, y, z : reel) ;
Debut
y 2*z ;
Si x > x/(y - z) alors
x x - 2;
y y / 4;
z z / 5;
F(x, y, z);
Fsi
Fin ;

58
Solutions
1.
Pour i=2 n faire O(n)
ki-1 ; O(1)
xT[i] O(1)
Tantque T[k]>x Faire O(n)
T[k+1] T[k] ; O(1)
kk-1 O(1)
FTq
T[k+1] x
FPour

O(n
2
)
2.
La boucle interne (TQ j > 1) fait 2*i itrations.
Pour i=n la boucle interne fait (2n - 1) itrations,
Pour i=n/2, elle fait (n -1) itrations,
puis n/2 - 1,
n/4 - 1,
n/8 -1,
:
2-1.
Donc le nombre total d'itrations est : 2n-1 + n-1 + n/2 - 1 +n/2
2
- 1 + n/2
3
- 1 + ... + 2-1 = 4n - log2n
donc en O(n).
3.
O(n)
Lalgorithme calcule : Fib(n) = Fib(n-1) + Fib (n-2) si n>1
1 sinon
4.
Fonction Fib(n:entier):entier
Debut
Si n < 2 alors
Fib 1; cot = a
Sinon
Fib Fib(n - 1)+Fib(n - 2) cot = b
Fsi
Fin

Fib (n) b b
Fib(n-1) b Fib(n-2) b 2b
Fib(n-2) b Fib(n-3) b Fib(n-3) b Fib(n-4) b 4b
. . . .
. . . . 2
n-2
b
a a a a a a a a a a a 2
n-1
a

Complexit = O( b+ 2b + 4b + 8b + + (2
n-2
)b+2
n-1
a))
= O( (2
n-1
-1)b+2
n-1
a))
= O( (2
n-1
(a+b) - b)) = O(2
n
)

5.
On a deux boucles imbriques.
- La premire fait n itrations (pour I=1,n ...)
- et la deuxime n*n itrations : K varie de 1 n pour chaque valeur de J qui varie de 1 n.

59
Donc la complexit de tout le programme est en O(n
3
).

6.
La boucle interne fait environ 2 log
2
n itration, car j varie de 1 2n par progression logarithmique
(j j*2) . La boucle externe fait n itrations, donc les deux boucle imbriques font n * 2log
2
n itrations.
Les instructions autre que les boucles sont des affectations (o(1)), donc la complexit de lalgorithme
entier est en O(n log n).

7.
On remarque que la fonction f retourne la valeur ((i-j) div k) +1 dans le cas o k+j=i, c-a-d lorsque k = i-j
et dans ce cas l, la valeur retourne est donc (k div k) + 1 = 2. On remarque alors que les deux appels
internes dcrmentent la quantit k+j i :
dans lappel f(i,j+1,k-2) on a k-2 + j+1 - i = k+j-i 1
dans lappel f(i+1,j+x,k-2) on a k-2+j+x-(i+1) = k+j-i 1
Donc si on pose T(i,j,k) le temps ncessaire pour un appel f(i,j,k) on a alors lquation de rcurrence :
T(i,j,k) = a si k+j=i
T(i,j,k) = b + T(i,j+1,k-2) + T(i+1,j+2,k-2) sinon
on peut se ramener une fonction un argument si on pose n = k+j-i et t
n
= T(i,j,k), on aura alors :
t
n
= a si n = 0
t
n
= b + 2t
n-1
sinon
On procde par remplacement de proche en proche :
t
n
= b + 2t
n-1

= b + 2(b + 2t
n-2
) = 3b + 4 t
n-3

= 7b + 8 t
n-4

= 15b + 16t
n-5

: :
: :
= (2
n
1)b + 2
n
a
= 2
n
(b+a) b
La complexit est donc en O(2
n
(b+a) b) = O(2
n
)
T(i,j,k) est alors en O(2
k+j-i
)

8.
La variable J est multiplie par 2 chaque itration, donc pour atteindre la valeur n il faut log
2
n itrations.
A chaque fois que J atteint n, la variable I est incrmente. Pour que I atteint la valeur n il faut faire n*log
2

n itrations. Donc la complexit de lalgorithme est O(n log n).

9.
Le temps dexcution de la fonction F(x,y,z) dpend uniquement de z, car le test : SI x>x/(y-z) se simplifie
en :
SI z>1 car y reoit la valeur 2*z juste avant le test. Donc le corps de la fonction est quivalent :
y 2*z ; SI z>1 : x x-1 ; y y/4 ; z z/5 ; F(x,y,z) FSI

Posons T(z) le temps dexcution de F(x,y,z). Donc T(z) = a si z<=1 et T(z) = T(z/5)+b sinon.
T(z) = T(z/5)+b = T(z/25)+2b = t(z/125)+3b = = T(z/5
i

)+ib = T(1)+log
5
z b
Pour z une puissance de 5 on aura T(z) = a + b log
5
z
Donc la complexit est en O(log z).

60
2. Listes linaires chanes
Exercice 1 : Algorithmes de base
Ecrire les algorithmes de base suivants sur les listes linaires chanes unidirectionnelles:
1. Suppression par valeur.
2. Suppression par position.
3. Inversement dune liste :
a. En crant une nouvelle liste.
b. Sans crer une nouvelle liste (En gardant les mmes maillons)
4. Tri par la mthode "slection et permutation".
5. Tri par la mthode des bulles.
6. Recherche de l'lment qui a le plus grand nombre d'occurrences.
Ecrire les algorithmes de base suivants sue les listes linaires chanes bidirectionnelle:
1. Rechercher l'lment x s'il existe.
2. Supprimer l'lment x s'il existe.
3. Inversement dune liste.
Exercice 2 :
Soit une liste linaire chane contenant des nombres entiers et dont la tte est L :
1. Ecrire la fonction CAR(L) qui retourne la valeur du premier lment de la liste.
2. Ecrire la fonction CDR(L) qui retourne la liste sans le premier lment.
3. Ecrire la fonction CONS(x, L) qui retourne une liste dont le premier lment est x et le reste est la
liste L.
4. Ecrire la fonction Trie(L) qui retourne vrai si la liste L est trie dans lordre croissant et faux
sinon.
5. Ecrire la fonction Fusion(L1, L2) qui prend deux listes tries dans lordre croissant L1 et L2 et
retourne une liste trie, dans le mme ordre, contenant les deux listes et cela en utilisant les
fonctions prcdentes.
Exercice 2 : Diffrence de deux listes linaires chanes
Soient L1 et L2 deux listes linaires chanes unidirectionnelle. Construire la liste L = L1 - L2
contenant tous les lments appartenant L1 et n'appartenant pas L2.
Exercice 3 : Liste de nombre premiers
Nous considrons la construction d'une liste des nombres premiers infrieurs ou gaux un entier n
donne. Pour construire cette liste, on commence, dans une premire phase, par y ajouter tous les entiers
de 2 n en commenant par le plus grand et en terminant par le plus petit qui se trouvera la tte de la
liste. On considre ensuite successivement les lments de la liste dans l'ordre croissant en on supprime
tous leurs multiples stricts. Ecrire cet algorithme.
Exercice 4: Listes de caractres
Nous considrons la reprsentation dune chane de caractres sous forme de LLC o chaque maillon
contient un caractre.
Ecrire la fonction qui vrifie quune liste est un palindrome ou non dans le cas de :
1. Liste doublement chane.
2. Liste dans un seul sens.
Une liste est dite palindrome si elle est de la forme a
1
a
2
...a
n
ba
n
a
2
a
1
Exercice 5 : Matrices creuses

Une matrice est dite creuse lorsque le nombre d'lments nuls y figurant est trs suprieur celui des
lments non nuls. On peut reprsenter une matrice creuse en ne tenant compte que des lments non nuls.
Chaque ligne de la matrice est une liste linaire chane ordonne (selon le rang de la colonne) des
lments non nuls. Une table de N lments ( N tant le nombre de lignes de la matrice) donne les
adresses de tte de chacune des listes. Un lment de la liste contient l'indice de la colonne et la valeur de
l'lment.
- Dcrire la structure de donnes.
- Remplir une telle structure partir d'une matrice A(M, N) donne.
- Raliser la somme de 2 matrices ainsi reprsentes.
Sachant qu'un lment de la matrice occupe 4 octets, qu'un pointeur occupe 2 octets et qu'un indice
occupe 2 octets,
- quel est le gain d'espace quand le nombre de zros est de % ?
- quelle valeur minimale attribue pour que l'on puisse opter pour une telle reprsentation ?
Exercice 6 : Reprsentation d'un nombre binaire en une liste linaire chane.
On convient de reprsenter un nombre binaire b1b2..bn, o chaque bi est un 0 ou un 1, par une liste
linaire chane o chaque lment contient un bi.
Considrons la procdure rcursive suivante :
L est une liste linaire chane reprsentant un nombre binaire,
R est une variable globale initialise 1,
A mod B dsigne le reste de la division de A par B.
Procedure P(L: Pointeur(Tmaillon) );
var x : entier;
Debut
si L # nil alors
P( Suivant(L)) ;
x Valeur(L) + R ;
Aff_val(L, x mod 2);
si x=2 alors R 1
sinon R 0
fsi
fsi
Fin ;
Donner les diffrentes valeurs de L et X, dans l'ordre, aprs l'appel rcursif pour la liste suivante
reprsentant le nombre 1011 :
61

Que fait cette procdure ?
Ecrire un algorithme qui utilise cette procdure pour incrmenter un nombre binaire ainsi reprsent.
Exercice 7 : Interclassement de n listes linaires chanes
Soit T un tableau de n listes linaires chanes ordonnes.
1. Transformer T en une Liste L de listes sans cration de nouvelles listes
2. Donner la procdure qui affiche tous les lments de L.
3. Crer une liste ordonne LD contenant tous les lments de T en parcourant paralllement les n
listes de T (Interclassement)
4. Eliminer les doubles dans LD.

62
Solutions
Exercice1
1. Elment nombre max doccurrences
Val :Typeqq ;
End ;
Type TMaillonOcc=Structure
Val :Typeqq ;
NbOcc : entier ;
Suivant :Pointeur(TMaillonOcc)
End ;

Procedure Chercher(TeteOcc : Pointeur(TMaillonOcc), x :Typeqq, Q : Pointeur(TMaillonOcc))
Debut
Q TeteOcc ;
TQ Q<>Nil et Valaur(Q)<>x Faire
Q Suivant(Q) ;
FTQ
Fin ;

Fonction MaxOcc(TeteOcc : Pointeur(TMaillonOcc)) :Typeqq ;
Var PMax,P1 : Pointeur(TMaillonOcc) ;
Debut
P1TeteOcc ;
PMax P1 ;
TQ P1 <> Nil Faire
Si Valaur(P1)>Valeur(PMax) alors
PMax P1 ;
FSi ;
FTQ ;
MaxOccValeur(P1) ;
Fin ;
Fonction PGNOcc(Tete :Pinteur(TMaillon)) : Typeqq ;
Var P : Pinteur(TMaillon) ;
TeteOcc, Q, Q1 : Pinteur(TMaillonOcc) ;
Debut
TeteOccNil ;
PTete ;
TQ P <> Nil Faire
Chercher(Valeur(P),TeteOcc,Q) ;
Si Q = Nil Alors
Allouer(Q1) ;
Aff_Val(Q1,Valuer(P)) ;
Aff _ValOcc(Q1,1) ;
Aff_Adr(Q1,TeteOcc) ;
TeteOccQ1 ;
Sinon
Aff_ValOcc(Q1,ValeurOcc(Q1)+1 ;
Fsi ;
PSuivant(P) ;
FTQ

63
PGNOccMax(TeteOcc) ;
Fin ;
2. Suppression par valeur

Procedure SuppVal(Tete:Pinteur(TMaillon), x :Entier) ;
Var P1,PP1 :Pointeur(TMaillon) ;
Debut
P1 Tete ;
PP1 Nil ;
TQ P1<> Nil & Valeur(P1) <> x Faire
PP1 P1 ;
P1 Suiavnt(P1) ;
FTQ
Si P1<> Nil alors
Si PP1=Nil alors Tete Suivant(Tete)
Sinon Aff_Adr(Prec,Suivant(p))
FSi
Liberer(P) ;
FSi
Fin ;
3. Suppression par position

Procedure SuppPos(Tete:Pinteur(TMaillon), Pos :Entier) ;
I :entier ;
Debut
P1 Tete ;
PP1 Nil ;
i1 ;
TQ P1<> Nil & i < Pos Faire
PP1 P1 ;
P1 Suiavnt(P1) ;
ii+1 ;
FTQ
Si P1<> Nil alors
FSi
Liberer(P) ;
FSi
Fin ;
4. Inversement dune liste
a. Sans Allocation
Procedure Inverser(Tete : Pointeur(TMaillon)) ;
Var Var NTeteP : Pointeur(TMaillon) ;
Debut
NTete Nil ;
TQ Tete<>Nil Faire
PTete ;
TeteSuivant(Tete) ;
Aff_Adr(P,NTete) ;
NTeteP;
FTQ ;

64
PTete ;
TeteNTete ;
Fin ;

b. Avec Allocation
Procedure Inverser(Tete : Pointeur(TMaillon)) ;
Var NTete, Q, P : Pointeur(TMaillon) ;
Debut
NTete Nil ;
P Tete ;
TQ P<>Nil Faire
Allouer(Q) ;
Aff_Val(Q,Valaur(P)) ;
Aff_Adr(Q,NTete) ;
NTeteQ ;
FTQ ;

PTete ;
TeteNTete ;
TQ P<>Nil Faire
QP ;
PSuivant(P) ;
Liberer(Q) ;
FTQ ;
Fin ;

Exercice 2
Soit le prdicat Exist(Val, L) gal VRAI si l'lment Val appartient la liste L, FAUX Sinon. Soit S le
type d'un maillon.
Le prdicat Exist peut tre dfini comme suit :

Exist FAUX
P L
TANTQUE P <> NIL ET NON Exist :
SI Valeur(P) = Val
Exist VRAI
SINON P Suivant(P) FSI
FINTANTQUE

Diffrence de 2 listes
L'algorithme qui construit la diffrence de deux listes L1 et L2 est le suivant ( L3 constitue la liste
rsultante) :
L3 NIL
P L1
Q <-- NIL
TANTQUE P <> NIL :
SI NON Exist( Valeur(P), L2)
R Q
Allouer ( Q )
Aff_Val( Q, Valeur(P) )
Aff_Adr(Q, NIL)
SI R <> NIL

65
Aff_Adr(R,Q)
SINON L3 Q FSI
FSI
P Suivant (P)
FINTANTQUE

Exercice 3

Val :entier ;
End ;

Algorithme ListePremiers ;
Var n,i :entier ;
Tete,P,Prec :Poiteur(TMaillon)
Procedure SuppVal(Tete:Pinteur(TMaillon), x :Entier) ;
Debut
P1 Tete ;
PP1 Nil ;
TQ P1<> Nil & Valeur(P1) <> x Faire
PP1 P1 ;
P1 Suiavnt(P1) ;
FTQ
Si P1<> Nil alors
FSi
Liberer(P) ;
FSi
Fin ;
Debut
Lire(n) ;
Tete Nil ;
Pour i=2 n Faire /* Cration de la liste */
Allouer(P) ;
Aff_Val(P,i) ;
Aff_Adr(P,Tete) ;
Tete P ;
FPour

PTete ; /* Supprimer les non premiers */
TQ P<> Nil faire
Pour i=2 a n/i Faire
SuppVal(Tete, Valeur(P)*i) ;
FPour ;
P Suivant(P) ;
FTQ

P Tete ;
TQ p<> Nil Faire
Ecrire (Valaur(P)) ;

66
P Suivant(P) ;
FTQ ;
Fin ;

Exercice 4
1. Liste bidirectionnelle
Val : Caractre ;
Suivant,Precedent :Pointeur(TMaillon) ;
Fin ;

Fonction Palindrome(Tete,Queue :Pointeur(TMaillon)) :Booleen ;
Var P,Q : Pointeur(TMaillon) ;
Debut
P Tete ;
Q Queue ;
TQ (P<>Nil) & (P<>Q) & (Suivant(Q) <> P) et (Valeur(P)=Valeur(Q)) Faire
P Suivant(P) ;
Q Precedent(Q) ;
FTQ ;
Palindrome ((P = Nil) ou (P = Q) ou (Suivant(Q) = P)) ;
Fin ;
2. Liste unidirectionnelle
Val: Caractre ;
Suivant: Pointeur(TMaillon) ;
Fin ;

Fonction Palindrome(Tete :Pointeur(TMaillon)) :Booleen ;
Var P,Q,Queue : Pointeur(TMaillon) ;
Palind :Booleen ;
Debut
P Tete ;
Queue Nil;
TQ (P<>Nil) Faire
Allouer(Q) ;
Aff_Val(Q,Valeur(P)) ;
Aff_Adr(Q,Queue) ;
Queue Q ;
FTQ ;
P Tete ;
Q Queue ;
TQ (P <> Nil) & (Valaur(P) = Valeur (Q)) faire
P Suivant(P) ;
Q Suivant(Q) ;
FTQ ;
Palind (P=Nil) ;
TQ Queue<>Nil Faire
QQueue ;
Queue Suivant(Q) ;
Liberer(Q) ;
FTQ ;
Palindrome Palind;

67
Fin ;
Exercice 5
Structure de donnes

Type d'un maillon de la liste

TYPE M = STRUCTURE
Val : T
Adr : POINTEUR(M)
FIN

Type du champ Val d'un maillon de la liste

TYPE T = STRUCTURE
Indice : ENTIER
Val : ENTIER
FIN

VAR Tab : Tableau[1..M] DE POINTEUR(M) { Tableau de listes }

Remplissage de la structure

POUR I= 1, M :
Tab(I) NIL ; P NIL
POUR J = 1, N :
LIRE( A(I, J) )
SI A(I, J) # 0 :
Allouer(Q)
Aff_Val(Q, (J, A(I, J))
SI P#NIL :
Aff_Adr( P, Q)
SINON Tab(I) = Q FSI
P Q
FSI
FINPOUR
Aff_Adr(P, NIL)
FINPOUR

Somme de 2 matrices

Soient Tab1 et Tab2 deux tableaux de type POINTEUR(M) reprsentant les matrices additionner; Val
est un objet de type T. Tab dsigne la matrice rsultante.

POUR I = 1, M
P1 Tab1(I) ; P2 Tab2(I) ; P NIL;
TANTQUE P1 # NIL ET P2 # NIL :
SI Valeur(P1).Ind = Valeur(P2).Ind
Val (Valeur(P1).Ind, Valeur(P1).Val +
Valeur(P2).Val )
P1 Suivant(P1)
P2 Suivant(P2)
SINON
SI Valeur(P1).Ind < Valeur(P2).Ind

68
Val Valeur(P1)
P1 Suivant(P1)
SINON
Val Valeur(P2)
P2 Suivant(P2)
FSI
FSI
SI Val.Val # 0 :
Allouer(Q)
Aff_Val(Q, Val)
SI P# NIL : Aff_Adr(P, Q)
SINON Tab(I) Q FSI
P Q
FSI
FINTANTQUE
TANTQUE P1 # NIL :
Allouer(Q)
Aff_Val(Q, Valeur(P1))
SINON Tab(I) Q FSI
P1 Suivant(P1)
P Q
FINTANTQUE
TANTQUE P2 # NIL :
Allouer(Q)
Aff_Val(Q, Valeur(P2))
SINON Tab(I) Q FSI
P2 Suivant(P2)
P Q
FINTANTQUE
FINPOUR

Gain d'espace

Si on utilise un tableau A[M, N] on a : 4MN octets.
Avec la structure on a : 8MN(1-/100) + 2M
Donc le gain est M( N ( 0.08 - 4) - 2 ).

Par exemple, pour une matrice 4X5 et un = 80 le gain est de 40 octets.

Valeur minimale de

Il suffit de trouver telle que
8MN (1-/100) + 2M < 4MN
on a donc
2(1-/100) + 1/2N < 1
ou
1 + 1/2N < /50
c'est dire > 50 + 25/N
Par exemple, pour une matrice 4X5, devrait tre suprieure 55.

Exercice 6

69
Valeurs de L et X

L = P3, P2, P1, L
X = 2, 2, 1, 1

Rle de la procdure

La procdure P ajoute 1 au nombre binaire reprsent sous forme de liste linaire chane. Si la retenue se
propage au del du premier lment, la procdure P ne le traite pas. Les lments de la liste sont traits de
la queue la tte de la liste. Pour chaque lment, la valeur R est rajoute ( en base 2). R tant la retenue.

Incrmentation d'un nombre binaire

S tant le type du maillon de la liste.

R 1
P(L)
SI R = 1
Allouer(Q)
Aff_Val(Q, 1)
Aff_Adr(Q, L)
L Q
FSI
Exercice 7
Element ( V[i] ) : accs au i-me lment du vecteur V.
Aff_element( V[i], Val) : affecter la valeur Val au i-me lment du vecteur V.
Cration d'une liste (Tetell) de listes partir de V

Soient I un entier Pll , Qll , Tetell des listes de listes d'entiers

Tetell NIL
POUR I = 1 , 5
ALLOUER ( Pll )
AFF_VAL ( Pll , ELEMENT ( V [ I ] ) )
SI Tetell <> NIL
AFF_ADR ( Qll , Pll )
SINON
Tetell Pll
FSI
Qll Pll
FPOUR
AFF_ADR ( Pll , NIL )

Affichage de la liste de listes

Soit Tetell une listes de listes d'entiers et Pl une liste d'entiers.

Pll Tetell

70
TANTQUE Pll <> NIL
Pl VALEUR ( Pll )
TANTQUE Pl <> NIL :
ECRIRE ( VALEUR ( Pl ) )
Pl SUIVANT ( Pl )
FTANTQUE
Pll SUIVANT ( Pll )
FTANTQUE

Interclassement

Soient Tetel la liste d'entiers crer et Point un vecteur ( 5 ) de listes d'entiers.

POUR I = 1 , 5
AFF_ELEMENT ( Point [ I ] , ELEMENT ( V [ I ] ) )
FPOUR
Tetel NIL
Arret FAUX
TANTQUE NON Arret

{ recherche du min }
Inf 1000 { + infini }
Indinf 0
POUR I = 1 , 5
SI ELEMENT ( Point [ I ] ) <> NIL
SI VALEUR ( ELEMENT ( Point [ I ] ) ) < Inf
Inf VALEUR ( ELEMENT ( Point [ I ] ) )
Indinf I
FSI
FSI
FPOUR

SI Indinf <> 0
ALLOUER ( Pl )
AFF_VAL ( Pl , VALEUR ( ELEMENT ( Point [ Indinf ] ) ) )
SI Tetel ^= NIL
AFF_ADR ( Ql , Pl )
SINON
Tetel Pl
FSI
Ql Pl
AFF_ELEMENT ( Point [ Indinf ] ,
SUIVANT ( ELEMENT ( Point [ Indinf ] ) ) )
SINON
Arret VRAI
FSI
FTANTQUE
AFF_ADR ( Pl , NIL )

Supprimer les doubles

Soit Tetel une liste d'entiers.

71
{On suppose la liste non vide }
Pl Tetel
TANTQUE SUIVANT ( Pl ) <> NIL
SI VALEUR ( Pl ) = VALEUR ( SUIVANT ( Pl ) )
Ql SUIVANT ( Pl )
AFF_ADR ( Pl , SUIVANT ( SUIVANT ( Pl ) ) )
LIBERER ( Ql )
SINON
Pl SUIVANT ( Pl )
FSI
FTANTQUE

3. Piles et Files
Exercice 1
Ecrire un algorithme qui permette dafficher les lments dune liste linaire chane dans lordre
inverse en utilisant une pile.
Exercice 2 : La tour de Hanoi
Il s'agit d'un jeu de rflexion dont voici le principe. Des anneaux de diamtres diffrents sont empils
sur un poteau. Un anneau peut tre empil sur un autre seulement si il a un diamtre infrieur celui de
l'anneau sur lequel il repose.

Correct Interdit

Le but du jeu est de dplacer n anneaux initialement empils sur un seul poteau vers un autre en
respectant les rgles du jeu et en n'utilisant qu'un seul poteau intermdiaire.

- Ecrire un algorithme qui permette dafficher les tapes ncessaires pour le dplacement de n
anneaux dun poteau A vers un poteau C en passant par le poteau intermdiaire B en utilisant trois piles.
Exercice 3 : Evaluation d'une expression arithmtique post-fixe
Une expression arithmtique post-fixe est une expression o les oprandes sont placs avant les
oprateurs.
Exemple : l'expression (( a + b + c ) * ( a * b / c ) ) / c est exprime comme suit : ab+c+ab*c/*c/

1- Reprsenter les expressions suivantes sous forme post-fixe :
a + b, (a + b) / d, ((c + d) + (d e)) + 5, - (a + b) + (5 + b) c, ((a + b) + (c- d)) / 5.
2- Donner l'algorithme qui value une expression arithmtique post-fixe. On suppose que cette
dernire se trouve dans un tableau dont les lment sont de type : (Valeur, Type (oprateur ou oprande)).
Exercice 4
Une file dattente avec priorit est une file o les lments sont caractriss par une priorit de
service : un lment de priorit suprieur est servi mme sil nest pas arriv le premier.
72

- Dcrire les structures ncessaires limplmentation de ce modle en utilisant les listes.
- Ecrire les procdures Enfiler et Dfiler de ce modle.
- Expliquer comment peut-on implmenter une pile laide dune file dattente avec priorit.
- Expliquer comment peut-on implmenter une file dattente ordinaire laide dune file dattente
avec priorit.
Exercice 5
Ecrire un algorithme qui permette dimplmenter le modle des files dattente ne utilisant deux piles.
Exercice 6
Soit le labyrinthe suivant :

Entre (1,2)
Sortie (8,3)

1 2 3 4 5 6 7 8
E

1

73

1. Dcrire les structures de donnes ncessaires la reprsentation dun labyrinthe NxN en
mmoire.
2. Ecrire la procdure qui vrifie sil existe un chemin allant dune entre donne vers une sortie
donne en utilisant une pile.

2
3
4
5
6
7
8
S

74
Solutions

Exercice 1 :
Inversement dune liste chane :
Procedure Inverser(Tete : pointeur vers Tmaillon)) ;
Var Pile : Pointeur(Tmaillon) ;
DQ, Q : pointeur(Tmaillon) ;
Val : Typeqq ;
Debut
Init_Pile(P) ;
Tantque (Tete # Nil) Faire {empiler les valeur de la liste dans la pile et librer la liste}
Q Tete ;
Empiler(Pile, Valeur(Q)) ;
Librer(Q) ;
FTQ
Tantque NON Pile_vide(Pile) Faire {Cration de la liste inverse}
Allouer(Q) ;
Dpiler(P, Val) ;
Aff_Val(Q, Val) ;
Aff_Adr(Q, Nil) ;
Si Tete = Nil Alors Tete Q
Sinon Aff_Adr(Dern, Q) ; {Insertion Fin: Dern pointe toujours vers le dernier lment}
Dern Q ;
FTQ
Fin;

Exercice 2:
Algorithme Hanoi ;
Var Poteaux : Tableau [1..3] de Pointeur(TPile) ; {chaque lment pointe vers une pile}
N, i : entier ;
Procedure Deplacer(NDisque, De, Vers: entier)
Debut
Si NDisque = 1 Alors { Sil y a un seul disque}
Dpiler (Poteaux[De], x) ; {Dpiler le disque de la Pile de dpart : indice De}
Empiler (Poteaux[Vers], x) ; {Empiler le disque Dans la Pile darrive : indice Vers}
Ecrire(Dplacer, x, De, De, vers, Vers) ;
Sinon {Sil y a deux disque ou plus}
Interm 6-De-Vers ; {Calculer lindice du poteau intermdiaire}
Deplacer ( NDisque-1, De, Interm) ; {Dplacer NDisque-1 du poteau De au poteau Interm en
utilisant le poteau Vers}
Deplacer (1, De, Vers) ; {Dplacer le disque n1 du disque de dpart au disque darrive}
Deplacer (NDisque-1, Interm, Vers) ; {Dplacer NDisque-1 du poteau Interm au poteau Vers
en utilisant le poteau De}
Fin ;
Debut
Lire(N) ; {lire le nombre de disques}
Pour i= 1 3 Faire
Init_Pile(Poteaux[i]) ; {initialiser les 3 piles}
Fpour
Pour i= 1 N Faire
Empiler(Poteaux[1], i) ; {Empiler N disques dans la pile associe au poteaux n1}

Fpour
Deplacer(N, 1, 3) ; { Appeler la procedure rcursive pour N disque, le poteaux de dpart n1 et le
Fin ; poteau darrive n3}

Exercice 3 :
Algorithme Eval_Exp ;
Type TElem = STRUCTURE
Val : chaine
Type: Booleen {Vrai: oprateur, Faux : oprande}
Fin ;
TPile = STRUCTURE
Val : Reel ;
Suivant : Pointeur (TPile) ;
Fin ;
Var Exp : Tableau [1..N] de TElem ;
P : pointeur (TPile) ;
i : entier ;
x, y, R : Reel ;
Debut
Pour i= 1 N Faire
Si Exp[i].Type = vrai Alors
Depiler(Pile, x) ;
Depiler(Pile, y) ;
Cas Exp[i].Val de
+ : R x + y ;
- : R y x ;
* : R x * y ;
/ : R y / x ;
FinCas ;
Empiler(Pile, R) ;
Sinon
Empiler(Pile, Reel(Exp[i].Val)); {la fonction Reel convertit une chaine en rel}
FSi ;
FPour ;
75
Fin.

Exercice 4 :
File dattente avec priorit.
1. Structure ncessaire :
Type TFile = STRUCTURE
Pr : entier ; {Priorit}
Precedent, Suivant : Pointeur(TFile) ;
Fin ;
2. Procedure Enfiler et dfiler
Procedure Enfiler (Tete, Queue : Pointeur(TFile), x : Typeqq) ;
Var P,Q : Pointeur(TFile) ;
Debut
Allouer(Q) ;
Aff_Val(Q,x) ;

P Queue ;
Tantque P # Nil et (Val_Pr(Q)>Val_Pr(P)) Faire
Nil
VAL VAL VAL VAL
Nil
Queue
Tete
Enfiler Enfiler = Ajouter Fin
Dfiler
Dfiler = Supprimer Dbut

76
P Precedent (P) ;
FTQ
Si Tete = Nil alors {La file est vide}

Aff_Adr_Suivant(Q,Nil) ;
Queue Q;
Tete Q ;
Sinon
Si P = Nil Alors {Le nouveau maillon a la plus haute priorit donc insertion dbut}
Aff_Adr_Precedent(Q,Nil) ;
Aff_Adr_Suivant(Q,Tete) ;
Tete Q ;
Sinon
Si P = Queue Alors {Le nouveau maillon a une priorit infrieure ou gale au dernier maillon}
Aff_Adr_Suivant(Q,Nil) ;
Aff_Adr_Precedent(Q, Queue) ;
Queue Q;
Sinon {Insertion milieu aprs ladresse P}
Aff_Adr_Precedent(Q, P) ;
Aff_Adr_Suivant(Q, Suivant(P)) ;
Aff_Adr_Precedent( Suivant(P), Q);
Aff_Adr_Suivant(P, Q) ;
FSi
FSi
FSi
Fin ;
La procdure Dfiler reste la mme.
Procedure Dfiler (Tete, Queue : Pointeur(TFile), x :entier) ;
Debut
Si Tete = Nil alors
Ecrire (Impossible, file vide) ;
Sinon
x Valeur(Tete) ;
P Tete ;
Si Tete=Nil alors Queue Nil ; FSi
Liberer(P) ;
FSi
Fin ;
3. Implmentation dune pile en utilisant une File avec priorit :
Pr 0 ; {Initialiser la priorit la valeur la plus basse}
Procedure Empiler(x) ;
Debut
Enfiler(x, Pr) ;
Pr Pr + 1 ; {Incrmenter la priorit pour la donner llment suivant}
Fin ;
Procedure Dpiler(x) ;
Debut
Dfiler(x) ;
Fin ;
4. Implmentation dune File ordinaire en utilisant une File avec priorit :
Pr Max ; {Initialiser la priorit la valeur maximale}
Enfiler (x)

Debut
Enfiler ( x, Pr) ; {enfiler de la File avec priorit}
Pr Pr 1 ;
Fin ;
Procedure Dfiler(x) ;
Debut
Dfiler(x) ; {Defiler de la File avec priorit}
Fin ;
Exercice 5 :
Implmenter une file dattente en utilisant deux piles.
Pile1, Pile2 : Pointeur(TPile) ;
Procedure Enfiler(x) ;
Dfiler (x)
Debut
Debut
Tantque NON Pile_vide(Pile1) Faire {vider la pile1 dans la pile2}
Dpiler(Pile1,x) ;
Dpiler(Pile1,y) ;
Fin ;
Empiler(Pile2, y) ;
FTQ ;
Empiler(Pile1, x) ; {Empiler x la base de Pile1}
Tantque NON Pile_vide(Pile2) Faire
Dpiler(Pile2,y) ;
Empiler(Pile1, y) ; {empiler les valeur de pile2 sur le x dans la pile1}
FTQ ;
Fin ;
Exercice 6 :
Algorithme Labyrinthe ;
Type TPile = STRUCTURE
x, y : entier ;
Suivant : pointeur(TPile) ;
Fin ;
Var Laby : Tableau [1..N, 1..N] de Booleen ; {la matrice qui reprsente les chemins du labyrinthe}
{Laby[i,j] = Faux case vide Laby[i,j] = Vrai
obstacle }
Visit : Tableau [1..N, 1..N] de Booleen ; {Visit[i,j] = Vrai case visite }
Pile : Pointeur(TPile) ;
xE, yE, xS, yS, x, y : entier ;
Debut
Init_Pile(Pile) ;
Lire (xE, yE) ; {lire les coordonns de lentre}
Lire (xS, yS) ; {lire les coordonns de la sortie}
Pour x=1 N Faire
Pour y=1 N Faire
Visit[x,y] Faux ; {initialisation de Visit Faux}
FPour
FPour
Empiler(Pile, (x,y)) ;
Tantque NON Pile_vide(Pile) Faire
Depiler (Pile, (x, y)) ;
Visit[x,y] vrai ;
Si x = xS et y = yS Alors
Ecrire (Une sortie existe) ;
Sinon {Vrifier toutes les cases voisines}
Si x<N et NON Laby [x+1, y] et NON Visit[x+1, y] alors
Empiler(Pile, (x+1, y)) ;
77

78
FSi
Si x>1 et NON Laby [x-1, y] et NON Visit[x-1, y] alors
Empiler(Pile, (x-1, y)) ;
FSi
Si y<N et NON Laby [x, y+1] et NON Visit[x, y+1] alors
Empiler(Pile, (x, y+1)) ;
FSi
Si y>1 et NON Laby [x, y-1] et NON Visit[x, y-1] alors
Empiler(Pile, (x, y-1)) ;
FSi
FSi FTQ Fin.

79
4. Arbres
Exercice 1 (arbres m-aires)
Ecrire sur les arbres m-aires les fonctions rcursives qui retournent:
- le pre dun nud donn.
- le maximum dans un arbre donn.
- minimum dans un arbre donn.

Exercice 2 (ARB)
1.
- Construire un arbre de recherche binaire partir des cls ordonnes suivantes :
25 60 35 10 5 20 65 45 70 40 50 55 30 15
- Ajouter larbre obtenu et dans lordre les lments suivants :
22 62 64 4 8
- Supprimer de larbre obtenu et dans lordre les lments suivants :
15 70 50 35 60 25
2. Ecrire sur les arbres de recherche binaires les fonctions rcursives qui retournent:
- vrai si un nud donn est une feuille et faux sinon.
- le nombre de feuilles de larbre.
- La taille de larbre.
- le successeur dun nud donn (llment immdiatement suprieur).
- le prdcesseur dun nud donn (llment immdiatement infrieur).
- le minimum dans un arbre donn.
- la hauteur dun arbre.

Exercice 3 (ARB)
Ecrire les algorithmes dinsertion et de suppression dans un ARB.

Exercice 4 (ARB)
Ecrire la fonction qui cre un arbre binaire de recherche quilibr partir dun tableau tri.

Exercice 5 (ARB)
Ecrire un algorithme itratif de parcours en profondeur dans un arbre de recherche binaire avec
utilisation de piles dans le cas dun parcours :
- Prordre (Pre FG FD)
- Inordre (FG Pre FD)
- PostOrdre (FG FD Pre)

Exercice 6 (Algorithme de Huffman : ARB)
Un village dAnglesey (petite le au sud-ouest de lAngleterre) porte lun des plus long nom au
monde : Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch
Les habitants du village sont fires de ce merveilleux nom mais ralisent, avec tristesse, que
(certainement par manque de bois !) toutes les affiches annoncant leur village ne contiennent quune toute
petit partie du nom originale : Llanfairpwll. Pour tre certain de prserver leur hritage culturel, ils
dcident dencoder le nom original de leur village en une squence de bits. Bien entendu, ils veulent que
cette squence soit la plus courte possible.
a) Faire un tableau de la frquence dapparitions de chacune des lettres apparaissant dans le nom du
village. (L et l considres comme tant la mme lettre, (frquence=nombre doccurrences de la lettre
divis par longueur du mot).

80
b) Utiliser ce tableau pour construire, avec lalgorithme de Huffman, larbre binaire donnant le
meilleur codage. (Lorsque plusieurs arbres on le mme poids -ici poids = frquence- choisir les arbres
selon lordre lexicographique)
c) Donner un tableau associant `a chacune des lettres son code binaire.
d) Quel est le nombre de bits minimal ncessaire pour encoder le nom de ce charmant village.

Pour les curieux : Ce nom de village nest pas une invention ! ! Le nom date du 19ime sicle et se
traduit, plus ou moins, comme : St Marys church in the hollow of the white hazel near a rapid whirlpool
and the church of St Tysilio of the red cave (voir http ://www.bbc.co.uk/h2g2/guide/A403642). Le nom
complet du village nest maintenant utilis que pour impressionner les touristes. Le nom Llanfairpwll
est utilis par les habitants.

Exercice 6 (tas)
- Construire un tas partir des cls ordonnes suivantes :
25 60 35 10 5 20 65 45 70 40 50 55 30 15
- Ajouter au tas et dans lordre les lments suivants :
22 62 64 4 8
- Supprimer du tas et dans lordre les lments suivants :
15 70 50 35 60 25

Exercice 7 (tas)
Ecrire les algorithmes dinsertion et de retrait dans un tas statique.
Ecrire les algorithmes dinsertion et de retrait dans un tas dynamique.
Exercice 8 (tas)
- Ecrire un algorithme qui permet de trier un tableau en utilisant un tas.
- Calculer la complexit de cet algorithme.

81
Solutions
Exercice 1 (arbres m-aires)
Fonction Pere(Racine: Pointeur(TNoeud), Val :Typeqq): Pointeur(TNoeud) ;
Var i: Entier ; P: Pointeur(TNoeud) ;
Debut
Si Racine=Nil alors Pere Nil ;
Sinon
i 1 ;
TantQue (i s n et Valeur(Fils
i
(Racine))=Val) Faire i i + 1 FTQ;
Si i<N alors Pere Racine
Sinon
i 1 ; P Nil ;
TantQue i s n et P=Nil Faire
P Pere(Fils
i
(Racine),Val) ;
i i + 1 ;
FTQ
Pere P ;
FSi
FSi
Fin ;
Fonction Max(Racine :Pointeur(TNoeud)) : entier ;
Var i, M, M1 : entier ;
Debut
Si Racine = Nil alors Ecrire(Max Impossible : arbre vide)
Sinon
M Valeur(Racine) ;
Pour i = 1 n faire
Si Filsi(Racine) = Nil alors
M1 Max(Filsi(Racine));
Si M1>M alors M M1 Fsi ;
FSi
FPour
Max M ;
FSi
Fin ;
Fonction Min(Racine :Pointeur(TNoeud)) : entier ;
Var i, M, M1 : entier ;
Debut
Si Racine = Nil alors Ecrire(Min Impossible : arbre vide)
Sinon
M Valeur(Racine) ;
Pour i = 1 n faire
Si Filsi(Racine) = Nil alors
M1 Min(Filsi(Racine));
Si M1<M alors M M1 Fsi ;
FSi
FPour
Min M ;
FSi
Fin ;


Exercice 2 (ARB)
1.
- Construire un arbre de recherche binaire partir des cls ordonnes suivantes :
25 60 35 10 5 20 65 45 70 40 50 55 30 15
25
82

10 60

5 20 35 65

15 30 45 70

40 50

55

- Ajouter larbre obtenu et dans lordre les lments suivants :
22 62 64 4 8

25

10 60

5 20 35 65

4 8 15 22 30 45 62 70

40 50

55

- Supprimer de larbre obtenu et dans lordre les lments suivants :
15 70 50 35 60 25
30

10 65

5 20 40

45

55

83
2. Ecrire sur les arbres de recherche binaires les fonctions rcursives qui retournent:
- Vrai si un nud donn est une feuille et faux sinon.
Fonction Feuille (Racine : Pointeur(TNoeud) ; xCl :Typeqq) : Booleen ;
Var N : Pointeur(TNoeud) ;
Debut
N Rechercher(Racine, xCl) ;
Si N = Nil Alors Ecrire( xCl,nexiste pas)
Sinon
Si FG(N) = NIL et FD(N)=NIL Alors Feuille Vrai
Sinon Feuille Faux ;
FSi
FSi
Fin ;

- le nombre de feuilles de larbre.
Fonction NBFeuilles(Racine : Pointeur(TNoeud)) : Entier ;
Debut
Si Racine = Nil Alors NBFeuilles 0
Sinon
Si (FG(Racine)=Nil et FD(Racine)=Nil) Alors NBFeuilles 1
Sinon NBFeuilles NBFeuilles (FG(Racine)) + NBFeuilles (FD(Racine))
FSi
FSi
Fin ;

- La taille de larbre.
Fonction Taille(Racine : Pointeur(TNoeud)) : Entier ;
Debut
Si Racine = Nil Alors Taille 0
Sinon
Taille 1+ Taille(FG(Racine)) + Taille(FD(Racine))
FSi
Fin ;

Fonction Pere(Racine : Pointeur(TNoeud) ; xCl :Typeqq) : Pointeur(TNoeud) ;
Var N, P : Pointeur(TNoeud) ;
Debut
N Racine ; P Nil ;
TantQue N=Nil et Cl(N)=xCl faire
P N ;
Si Cl(N) > xCl Alors N FG(N)
Sinon N FD(N)
FSi
FTQ
Si N=Nil alors Pere P
Sinon Pere Nil
Fsi ;
Fin ;

84
- le successeur dun nud donn (llment immdiatement suprieur).
Ide : On insre les cls dans une liste selon un parcours infixe, ensuite on cherche llment,
le sucesseur est son suivant dans la liste ;

Fonction Sucesseur(Racine : Pointeur(TNoeud) ; xCl :Typeqq) : Pointeur(TNoeud) ;
Var N :Pointeur (TNuoeud) ;
Tete, P, Q :Pointeur(TMaillon) ;

Procedure PPInfixe(R :Pointeur(TNoeud)) ;
Debut
Si R#Nil alors
PPInfixe(FG(R)) ;

Allouer(P) ; Aff_Val(P, Cl(R)) ; Aff_Adr(P,Nil) ;
Si Tete=Nil alors TeteP
Sinon Aff_Adr(Q,P)
Fsi ;
Q P ;

PPInfix(FD(R)) ;
Fin ;

Debut
Tete Nil ;
PPInfixe(Racine) ;
PTete ;
TantQue P# Nil et Valeur(P) # xCl faire P Suivant(P) FTQ ;
Si P# Nil alors Successeur Suivant(P)
Sinon Successeur Nil
FSi
Fin ;

- le prdcesseur dun nud donn (llment immdiatement infrieur).
Ide : On insre les cls dans une liste selon un parcours infixe, ensuite on cherche llment,
le prdcesseur est son prcdent dans la liste ;

Fonction Prdcesseur (Racine : Pointeur(TNoeud) ; xCl :Typeqq) : Pointeur(TNoeud) ;
Var N :Pointeur (TNuoeud) ;
Tete, P, Q :Pointeur(TMaillon) ;

Procedure PPInfixe(R :Pointeur(TNoeud)) ;
Debut
Si R#Nil alors
PPInfixe(FG(R)) ;

Allouer(P) ; Aff_Val(P, Cl(R)) ; Aff_Adr(P,Nil) ;
Si Tete=Nil alors TeteP
Sinon Aff_Adr(Q,P)
Fsi ;
Q P ;
PPInfix(FD(R)) ;
Fin ;

85

Debut
Tete Nil ;
PPInfixe(Racine) ;
PTete ;
QNil ;
TantQue P# Nil et Valeur(P) # xCl faire
Q P ;
P Suivant(P) ;
FTQ ;
Si P=Nil alors Prdcesseur Nil
Sinon Prdcesseur Q
FSi
Fin ;

Fonction Max(Racine :Pointeur(TNoeud)) : entier ;
Debut
N Racine ; P Nil ;
TantQue N=Nil faire
P N ;
N FD(N)
FTQ
Si N=Nil alors Max Cl(P)
Sinon Ecrire(Max impossible : arbre vide) ;
Fsi ;
Fin ;

- le minimum dans un arbre donn.
Fonction Min(Racine :Pointeur(TNoeud)) : entier ;
Debut
N Racine ; P Nil ;
TantQue N=Nil faire
P N ;
N FG(N)
FTQ
Si N=Nil alors Min Cl(P)
Sinon Ecrire(Min impossible : arbre vide) ;
Fsi ;
Fin ;

- la hauteur dun arbre.
Fonction Hauteur(Racine : Pointeur(TNoeud)) : Entier ;
Debut
Si Racine = Nil Alors Hauteur 0
Sinon
Hauteur 1+ Maximum(Hauteur (FG(Racine)) + Hauteur (FD(Racine)))
FSi
Fin ;

86

Exercice 3 (ARB)
Ecrire les algorithmes dinsertion et de suppression dans un ARB.
1-Insertion
Procedure Insrer(Racine : Pointeur(TNoeud) ; xCl :Typeqq) ;
Debut
N Racine ; P Nil ;
P N ;
Sinon N FD(N)
FSi
FTQ
Si N=Nil alors Ecrire(Insertion impossible,xCl,existe dj)
Sinon
Allouer(N1) ;
Aff_cl(N1, xCl) ; Aff_FG(N1, Nil) ; Aff_FD(N1, Nil) ;
Si P=Nil alors Racine N1
Sinon
Si Cl(P) > xCl Alors Aff_FG(P,N1)
Sinon Aff_FD(P,N1)
FSi
FSi
Fsi ;
Fin ;

2-Suppression
Procedure Supp_Feuille(Racine, N, PereN :Pointeur(TNoeud)) ;
Debut
Si PereN=Nil alors Racine Nil
Sinon
Si N=FG(PereN) alors Aff_FG(PereN,Nil)
Sinon Aff_FG(PereN,Nil)
Fsi ;
Liberer(N) ;
FSi ;
Fin ;

Procedure Suppression(Racine : Pointeur(TNoeud) ; xCl :Typeqq) ;
Debut
N Racine ; P Nil ;
P N ;
Sinon N FD(N)
FSi
FTQ
Si N=Nil alors Ecrire(Suppression impossible,xCl,nexiste pas)
Sinon
Si FG(N)=Nil et FD(N)=Nil alors Supp_Feuille(Racine, N, P)

87
Sinon
Si FG(N)=Nil alors
Q FD(N) ;
Supp_Feuille(Racine, P, N) ;
Si Cl(P) > Cl(Q) Alors Aff_FG(P,Q)
Sinon Aff_FD(P,Q)
Fsi ;
Sinon
Si FD(N)=Nil alors
Q FG(N) ;
Supp_Feuille(Racine, P, N) ;
Si Cl(P) > Cl(Q) Alors Aff_FG(P,Q)
Sinon Aff_FD(P,Q)
Fsi ;
Sinon
Q FD(N) ;
PQ N ;
N1 FG(N) ;
TantQue N1=Nil faire
PQ Q;
QN1 ;
N1FG(N1) ;
FTQ ;
Aff_Cl(N, Cl(Q)) ;
N1 FD(Q) ;
Supp_Feuille(Racine, Q, PQ) ;
Si N1 N1=Nil alors
Si Cl(PQ) > Cl(N1) Alors Aff_FG(PQ, N1)
Sinon Aff_FD(PQ, N1)
Fsi ;
FSi
FSi
Fsi
Fin ;
Exercice 4 (ARB)
Ecrire la fonction qui cre un arbre binaire de recherche quilibr partir dun tableau tri.

Fonction Arbre(T :Tableau[1..n] de entier ; Inf, Supp :entier) : Pointeur(TNoeud) ;
Var i,m :entier ;
P : pointeur(TNoeud) ;
Debut
Si inf>Supp Alors Arbre Nil
Sinon
Si (inf=Supp) Alors
M (Inf + Supp)/2;
Allouer(P);
Aff_Cl(P, T[M]) ;
Aff_FG(P, Arbre(T,Inf, M-1));
Aff_FD(P, Arbre(T,M+1,Supp);
Arbre P;
FSi
Fin ;

88

Exercice 5 (ARB)
Ecrire un algorithme itratif de parcours en profondeur dans un arbre de recherche binaire avec
utilisation de piles dans le cas dun parcours :
- Prordre (Pre FG FD)
Procedure Preordre(Racine : Pointeur(TNoeud) ) ;
P :Pile ;
Debut
Init_Pile(P) ;
Empiler(Racine) ;
TantQue Non(PileVide(P)) Faire
Dpiler(N);
Si FD(N) # Nil alors Empiler( FD(N)) Fsi ;
Si FG(N) # Nil alors Empiler( FG(N)) Fsi ;
FTanque ;
Fsi
Fin ;

- Inordre (FG Pre FD)
Impossible

- PostOrdre (FG FD Pre)
Procedure Postordre(Racine : Pointeur(TNoeud) ) ;
P1,P2 :Pile ;
Debut
Init_Pile(P1) ;
Init_Pile(P2) ;
Empiler(P1, Racine) ;
TantQue Non(PileVide(P1)) Faire
Dpiler(P1, N);
Empiler(P2, N) ;
Si FD(N) # Nil alors Empiler(P1, FD(N)) Fsi ;
Si FG(N) # Nil alors Empiler(P1, FG(N)) Fsi ;
FTanque ;

TantQue Non(PileVide(P2)) Faire
Dpiler(P2, N);
FTanque ;
Fsi
Fin ;

Exercice 6 (Algorithme de Huffman : ARB)
6
Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch

a) Faire un tableau de la frquence

Caractre Frquence Caractre Frquence
b 1 a 3
d 1 i 3
e 1

n 4
f 1 r 4
p 1 w 4
s 1 y 5
t 1 o 6
c 2 g 7
h 2 l 11

b) Construire larbre binaire donnant le meilleur codage.

89

c) Donner un tableau associant chacune des lettres son code binaire.

d) Quel est le nombre de bits minimal ncessaire pour encoder le nom de ce charmant village.
220 bits
Caractre Code Caractre Code
b 111111 a 0011
d 111110 i 0010
e 101111 n 0110
f 101110 r 1110
p 101101 w 1010
s 101100 y 000
t 01111 o 010
c 01110 g 110
h 11110 l 100
b
d
h 2
4
e f p s
2 2
4 r
8
w
8
15
l
19
a i
6
t c
3 n
7 y
11
o
13
24
34
58
1
0
0 1
1 0 1 0 1
0
g
1 0 1 0
1
0
0 1
0
0 1 1 0
1
0 1
0 1 0 1 1
0
0
1

Exercice 6 (tas)
- Construire un tas partir des cls ordonnes suivantes :
25 60 35 10 5 20 65 45 70 40 50 55 30 15

70

65 60

45 50 55 35

10 25 5 40 20 30 15 A

- Ajouter au tas et dans lordre les lments suivants :
22 62 64 4 8

70

65 60

64 50 55 35

62 25 5 40 20 30 15 22

10 45 4 8

- Supprimer du tas et dans lordre les lments suivants :
15 70 50 35 60 25
Impossible, on ne peut pas supprimer directement un lment dun tas, on ne peut que retirer
celui dans la racine

Exercice 7 (tas)
Ecrire les algorithmes dinsertion et de retrait dans un tas statique.
Var Tas: Tableau[1..n] de entier ;
NbCls :entier init 0;
Procedure InsrerTas(xCl :entier) ;
Var I, tmp : entier ;
Debut
Si NbCls=n alors Ecrire(Insertion impossible le tas est plein)
Sinon
NbCls NbCls + 1 ;
Tas[NbCls] xCl ;
I NbCls / 2 ;
TantQue I>0 Faire
Si Tas[I]<Tas[I*2] alors
tmp Tas[I] ;
Tas[I] Tas[I*2];
Tas[I*2] tmp;
I I / 2
Sinon
90

91
I 0
FSi
FTQ
Fin ;

Procedure RetirerTas(xCl :entier) ;
Debut
Si NbCls=0 alors Ecrire(Retrait impossible le tas est vide)
Sinon
xCl Tas[1] ;
Tas[1] Tas[NbCls];
NbCls NbCls - 1 ;
I 1 ;
TantQue I< (NbCls/2) Faire
Si Tas[I]<Tas[I*2] alors
tmp Tas[I] ;
Tas[I] Tas[I*2];
Tas[I*2] tmp;
I I * 2
Sinon
I NbCls
FSi
FTQ
Fin ;

Exercice 8 (tas)
- Ecrire un algorithme qui permet de trier un tableau en utilisant un tas.

Procedure TrierTableau(T :Tableau[1..n] de entier) ;
Debut
Pour I1 n Faire
InsrerTas(T[I]) ;
FPour ;

Pour I1 n Faire
RetiretTas(tmp) ;
T[I] tmp ;
FPour ;
Fin ;

- Calculer la complexit de cet algorithme.
O(nLog2(n))

92
5. Structures en tables et graphes
Structures en tables

Exercice

On veut enregistrer un annuaire tlphonique sur micro, en utilisant la mthode de HashCoding.
Chaque entre de la table reprsente les informations concernant une personne (Nom, prnom, Numro de
tlphone).
La cl considre est le nom, et la fonction de hachage est
H(cl) = (Code ASCII (1
er
car) + Code ASCII (2
eme
car) ) Mod N
O N est la taille de la table est gale 100.
Remarque : les caractres peuvent tre en majuscule ou en minuscule et il ne doit pas y avoir de
distinction.

Questions :
- Dcrire les structures de donnes ncessaires la reprsentation des donnes en cas
dutilisation de la mthode des LLCs pour rsoudre les collisions.
- Ecrire les procdures de recherche, dinsertion et de suppression.
- Rpter les mmes questions en utilisant la mthode dessai linaire.
- Rpter les mmes questions en utilisant la mthode de chanage interne spar.
Graphes

1- Ecrire une procdure permettant de crer un graphe en listes dadjacence partir dun graphe
reprsent sous forme dune matrice dadjacence.
2- Ecrire une procdure permettant de crer un graphe en une matrice dadjacence partir dun
graphe reprsent sous forme d listes dadjacence.
3- En utilisant le parcours DFS sur une matrice dadjacence :
1. Ecrire une fonction permettant de vrifier sil existe un chemin entre deux sommets
donns.
2. Ecrire une fonction permettant de vrifier sil existe une chane entre deux sommets
donns.
3. Ecrire une fonction permettant de vrifier sil existe un circuit dans le graphe.
4. Ecrire une fonction permettant de vrifier sil existe un cycle dans le graphe.
5. Ecrire une fonction permettant de vrifier si un graphe est cyclique ou non.
6. Ecrire une fonction permettant de dtecter les composantes connexes dun graphe sachant
quune composante connexe est un ensemble de sommets dont chaque paire est relie
par au moins une chane.
7. Ecrire une fonction permettant de dtecter les composantes fortement connexes dun
graphe sachant quune composante fortement connexe est un ensemble de sommets
dont chaque paire est relie par un chemin.
4- Reprendre les mmes exercices avec un graphe reprsent par des listes dadjacence.
5- Ecrire une procdure permettant de donnes les chemins minimums partir dun sommet donn
vers tous les autres en utilisant lalgorithme de Dijkstra.

93

Solutions
1. Structures en table :

1 LLCs
- Structures ncessaires
Type Entree=structure
Nom, Prenom, NumTel :Chaine ;
Suivant :Pointeur(Entree)
Fin ;

Var Table : Tableau[0..99] de Entree ;

Procedure Initialisation ;
Var i :entier ;
Debut
Pour i =0 99 faire
Table[i].Nom ;
Table[i].Suivant Nil ;
FPour ;
Fin ;

Fonction h(cle :chaine) : entier ;
Var c1,c2 :chaine ;
Debut
c1 Maj(Cle[1]) ; c2 Maj(Cle[2]) ; // Maj convertit le caractre en majiscule
h (Code(c1) + Code(c2)) mod 100 // Code donne le code ASCII du caractre.
Fin ;

Procedure Recherche (Cle : chaine , Pos :Entier , Ptr :Pointeur(Entree))
Var I : Entier ;
Debut
I h(cle);
Si Table[i].Nom=Cle alors Pos I;
Ptr Nil ;
Sinon
PtrTable[i].Suivant ;
TQ Ptr <> Nil et Cle(Ptr) <> Cle Faire
Ptr Suivant(Ptr)
FTQ
Si P<> Nil Alors Pos i ;
Sinon Pos -1 ;
FSi
FSi
Fin ;

// Recherche retourne la position Pos si llment existe et -1 sinon.
// En cas o llment existe Ptr=Nil si llment est dan la premire case, et ladresse du maillon
dans la liste sinon

94

Procedure Insertion(Nom, Prenom,Tel :chaine) ;
Var Pos :entier ;
P,Q,PP :Pointeur(Entree) ;
Debut
Recherche(cle, Pos, P) ;
Si Pos<> -1 alors ecrire((la cl existe dj)
Sinon
Pos h(cle) ;
Si Table[Pos].Nom= alors
Table[Pos].NomNom ;
Table[Pos].PrenomPrenom ;
Table[Pos].NomTel Tel ;
Sinon
Allouer(Q) ;
AffAdr(Q,Nil) ;
AffVal(Q,(Nom,Prenom,Tel)) ;
PTable[Pos].Suivant ;
Si P=Nil alors Table[Pos].Suivant Q ;
Sinon
PPP ;
TQ p<> Nil faire
PPP ;
PSuivant(P) ;
FTQ ;
AffAdr(PP,Q) ;
FSi
FSi
FSi
Fin ;
Procedure Suppression (cle :chaine) ;
Var Pos :entier ;
P,Q,PP :Pointeur(Entree) ;
Debut
Recherche(cle,Pos,P)
Si Pos=-1 alors ecrire( cette cl nexiste pas)
Sinon
Si P=Nil alors
QTable[Pos].Suivant ;
Table[Pos]Valeur (Table[Pos].Suivant) ;
Table[Pos].SuivantSuivant(Q) ;
Liberer(Q) ;
Sinon // Suppression dans une LLC
Q Table[Pos].Suivant ;
PPQ ;
TQ Q<>P faire
PP->Q ;
QSuivant(Q) ;
FTQ
Si PP=Q Alors Table[Pos].SuivantSuivant(P)
Sinon AffAdr(PP, Suivant(P) ;
Liberer(P) ;
FSi

95
FSi
Fin ;
2 Essai Linaire
Fin ;

Var Table : Tableau[0..99] de Entree ;
nNoms :entier ;

Precedure Initialisation ;
Var i :entier ;
Debut
Pour i 0 99 faire
Table[i].Nom ;
FPour ;
nNoms0 ;
Fin ;

Var c1,c2 :chaine ;
Debut
Fin ;

Fonction Recherche (cle: Chaine):entier;
var i: entier;
Debut
i h(x);
TQ (Table [i].Nom <> cle) et (Table [i].Nom <> '') Faire
i (i+1) mod100;
FTQ
Si Table [i].Nom = cle Alors Recherche i;
Sinon Recherche -1;
Fin

Procedure Insertion (Nom,Prenom,Tel : Chaine);
var i: entier;
Debut
Si nNoms >= 99 Alors Erreur ('De''bordement de la table'); // garder une case vide
Sinon
nNoms nNoms + 1;
i h(Nom);
TQ (Table [i].Nom <> Nom) et (Table [i].Nom <> '') faire
i (i+1) mod 100;
FTQ
Table [i].Nom Nom;
Table [i].Prenom Prenom;
Table [i].NumTel Tel;
FSi
Fin;

96

Procedure Suppression(cle:chaine);
Var i:entire;
Debut
iRecherche(cle);
Si i=-1 alors ecrire(cette cle nexiste pas)
Sinon
nNom nNoms-1 ;
Table [i].Nom ;
FSi
Fin;

3 Chainage interne spar
Suiv :entier ;
Fin ;

Var Table : Tableau[0..119] de Entree ; les 20 dernires entres pour les collisions
NbCollisions :Entier ;

Precedure Initialisation ;
Var i :entier ;
Debut
Pour i 0 119 faire
Table[i].Suiv -1 ;
Table[i].Nom ;
FPour ;
NbCollisions 0 ;
Fin ;

Var c1,c2 :chaine ;
Debut
Fin ;

Fonction Recherche (cle: Chaine): integer;
var i:entier;
Debut
i h(cle);
TQ (Table[i].nom <> x) et (Table[i].Suiv <> -1) faire
i Table[i].Suiv;
FTQ
Si (cle = Table[i].nom) Alors Recherche i
Sinon Recherche -1;
Fin ;

procedure Insertion (Nom,Prenom,Tel: Chaine);

97
var i: integer;
Debut
i h(Nom);
Si nom[i] = '' Alors
Table[i].nom Nom;
Table[i].Prenom PreNom;
Table[i].NumTel Tel;
Sinon
Si NbCollisions>=20 Alors ecrire('De''bordement de la table');
Sinon
Table[NbCollisions+100].nomnom;
Table[NbCollisions+100].PrenomPrenom;
Table[NbCollisions+100].NumTelTel;
Table[NbCollisions+100].Suiv Table[i].Suiv; // On met la nouvelle entre en
Table[i].Suiv NbCollisions+100 // tte de la liste des collisions
NbCollisions NbCollisions + 1; // de sa classe d'quivalence.
FSi
Fin ;

1.Graphes:

Successeur :entier ;
Suivant : Pointeur(TMaillon) ;
Fin ;
1.
Procedure CrerGraphe(GrapheMA:Tableau[1..n,1..n] de boolean ; GrapheLA :Tableau[1..n] de
Pointeur(TMaillon)) ;
Var i,j :entier ;
P :Pointeur(TMaillon) ;
Debut
Pour i =1 n faire
GrapheLA[i]Nil ;
Pour j=1 n faire
Si GrapheMA[i,j] alors
Allouer(P) ;
AffVal(P,j) ;
AffAdr(P,GrapheLA[i] ;
GrapheLA[i]P ;
FSi
FPour ;
FPour ;
Fin ;

2.
Procedure CrerGraphe(GrapheLA :Tableau[1..n] de Pointeur(TMaillon) ; GrapheMA:
Tableau[1..n,1..n] de boolean ) ;
Var i,j :entier ;
P :Pointeur(TMaillon) ;
Debut
Pour i=1 n faire
Pour j=1 n faire

98
GrapheMA[i,j] faux ;
FPour ;
FPour ;
Pour i =1 n faire
P GrapheLA[i] ;
TQ P<> Nil faire
GrapheMA[i,Valeur(P)]vrai ;
PSuivant(P) ;
FTQ ;
FPour ;
Fin ;
3.

1-
Fonction Existe_Chemin(i,j :entier) :booleen ;
Debut
Pour i =1 n faire
Visit[i]faux ;
FPour ;

DFS(i) ;
Existe_Chemin Visit[j] ;
Fin ;
2-
Pour vrifier lexistence dune chane, le parcours DFS doit tre modifi :

Graphe : tableau[1..n, 1..n] de booleen ;
Visit : tableau[1..n] de booleen initialis faux;

Procedure DFSC(sommet :entier)
Var i : entier ;
Debut
Visit[sommet] vrai ;
Afficher (sommet) ;
Pour i = 1 n faire
Si (Graphe[sommet,i] ou Graphe[i,Sommet] ) et non Visit[i] alors
DFSC(i) ;
FSi
FPour
Fin ;

Fonction Existe_Chane(i,j :entier) :booleen ;
Debut
Pour i =1 n faire
Visit[i]faux ;
FPour ;

DFSC(i) ;
Existe_Chane Visit[j] ;
Fin ;
3.
Fonction Existe_Circuit:booleen ;
Debut

99
Pour i =1 n faire
Pour j=1 n faire
Si i<>j et Existe_Chemin(i,j) et ExisteChemin(j,i) alors
ExisteCircuitvrai ;
Exit ;
FSi;
FPour ;
FPour
Existe_Circuit Faux ;
Fin ;

4.
Si on trouve une arret, on llimine et on cherche si on peut revenir dune autre chane.

Fonction Existe_Cycle :booleen ;
Debut
Pour i =1 n faire
Pour j =1 n faire
Pour k 1 n Visit[k]faux FPour ;
Si Graphe[i,j] ou Graphe[j,i] alors
B1 Graphe[i,j] ;
B2 Graphe[j,i] ;
Graphe[i,j] faux ;
Graphe[j,i] faux ;
DFSC(j) ;
Si Visit[i] alors
Exist_Cyclevrai ;
Graphe[i,j] B1 ;
Graphe[j,i] B2;
Exit;
FSi
Graphe[i,j] B1 ;
Graphe[j,i] B2;
FPour ;
FPour
Existe_CycleFaux ;
Fin ;

5.
Fonction Cyclique :Boolean ;
Debut
Cyclique Exist_Cycle ;
Fin

6.
Procedure ComposantesConnexes ;
Var Choisi :Tableau[1..n] de boolean ;
i,j,nc :entier ;
Debut
nc 0 ;
Pour i=1 n faire
Choisi[i] faux ;
Visit[i]Faux ;

100
FPour;
Pour i=1 n faire
Si non Visit[i) alors
DFSC(i) ;
ncnc+1
Ecrire(composante n,n) ;
Pour j=1 n faire
Si Visit[j] et non Choisi[j] alors
Ecrire(j) ;
Choisi[j]vrai ;
FSi
FPour ;
FSi
FPour
Fin ;

7.
Procedure ComposantesFortementConnexes ;
Var Choisi :Tableau[1..n] de boolean ;
i,j,nc :entier ;
Debut
nc 0 ;
Pour i=1 n faire
Choisi[i] faux ;
Visit[i]Faux ;
FPour;

Pour i=1 n faire
Si non Choisi[i] alors
nc nc+1 ;
Ecrire(Composante N,nc) ;
Ecrire(i );
Choisi[i]vrai ;
Pour j =1 n faire
Si i<>j et Exist_Chemin(i,j) et Exist_Chemin(j,i) alors
Ecrire(j);
Choisi[j]vrai ;
Fsi
FPour
FSi
FPour
Fin ;

101

6. Preuve de programmes
1. Ecrire un algorithme qui permette trouver deux lments gaux dans un tableau.
- Discuter la correction partielle de lalgorithme.
- Discuter la terminaison de cet algorithme.
2. Ecrire lalgorithme qui fusionne deux tableaux tris T1[N], T2[N] dans un nouveau tableau (tri)
T[2N].
- Discuter la correction partielle de lalgorithme.
- Discuter la terminaison de cet algorithme.
3. Soit lalgorithme suivant :
x 0 ; y 0 ; i 1 ; t 0 ;
TQ i < n faire
SI t = 1 alors
x x+ i ;
SINON
y y + i ;
FSI
t (t+1) mod 2 ;
i i + 1 ;
FTQ ;
z x + y ;
- Vrifier la terminaison de lalgorithme.
- Donner la fonction calcule par cet algorithme.
- Vrifier la correction partielle de cet algorithme.
- Donner le triplet de Hoare reprsentant la preuve de cet algorithme.
- Quelles sont les rgles utilises pour la preuve de la correction partielle de lalgorithme.
4. Soit lalgorithme itratif calculant la fonction factorielle dun entier, dj labor.
- Donner le triplet de Hoare utilis pour la preuve de cet algorithme.
- Donner larbre des rgles utilises pour prouver cet algorithme.

102
IX. Bibliographie

1. Introduction lAlgorithmique, cours et exercices; T.Cormen, C.Leiserson et C.Stein ;
Edition Dunod 2004.

2. Algorithmique et programmation, Michael Griffiths, Edition Herms 1992

3. Elments dalgorithmique ; D.Beauquier, J.Berstel, Ph.Chr_etienne, Edition Masson 2003

4. Algorithmique avances ; F. Vivien ; Universit de Lyon 2002.

5. Algorithmique ; Guillaume Poupard ; ENSTA 2000.

6. Type de donnes algorithmique ; Gaudel, Froideveaux et Soria ; INRIA

Polycope Algo2

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Polycope Algo2

Diunggah oleh

Hak Cipta:

Format Tersedia

REPUBLIQUE ALGERIENNE DEMOCRATIQUE ET POPULAIRE

MINISTERE DE LENSEIGNEMENT SUPERIEUR ET DE LA RECHERCHE

Anda mungkin juga menyukai