Plan de cours

I : Rappel : Concept de base

 Séquence
 Sélection
 Répétition
 Structure de données
1. Les tableaux (dimensions un et deux)
 Primitives
 Parcours
2. Les piles (lifo)
 Primitives
 Parcours
 Applications
 Les Files (FIFo)
 Primitives
 Parcours
 Applications
 Les listes linéaires
 Primitives
 Parcours
 Applications
 Listes bidirectionnelles
 Primitives
 Parcours
 Les structures arborescentes
 Primitives
 Parcours
 Applications
 Complexité des algorithmes
 Définitions
 Applications
Chapitre 1 : Concept de Base
I. Rappel :
Il y'a trois structure de contrôle à savoir
 La séquence
 La sélection
 La répétition
II. La Séquence
Les instructions d'un algorithme sont écrites de façon séquentielle. L'ordre
d'Exécution se fait selon l'ordre d'écriture.
I1
I2 avec Ii l'instruction i
I3
III. La sélection

Sont COND une condition

Act 1 et Act 2 deux actions élémentaires
La Sélection simple se formule comme suit :
Si COND alors
Sinon
Act2
Fin si
Remarque : Si Act2 ne correspond à rien
La sélection se réduit à :
Si COND alors
Act
Fin si
Exemple :
Si (argent disponible) alors
Acheter ('le produit')
Fin si
Remarque : Sélection multiple
Soient Act 0 -------- Act N actions
Cond1-------------CondN N Conditions

La syntaxe de la sélection multiple est la suivante :

Si Cond1 alors
Act1
Sinon
Si Cond2 Alors
Act 2
Sinon
Si Cond3 alors
Act3
Sinon
Si Cond N-1 alors
Act N-1
 Sinon
Act0
Fin si
Fin si
Fin si
Fin si

3.La Répétition

Il y'a 3 formes de répétition.

Soit Cond une condition, Act une Action

A. Tanque
La Syntaxe est la suivante ;
Tanque Cond faire
Act
Fin tanque
Dans ce format l'action peut ne jamais être exécuté
Exemple : X 10
Tanque (X > 0) faire
X X+5
Fin tanque
Jamais exécuté car X négatif au départ
B. Répéter
Syntaxe
Repeter
Act
Jusqu'à Cond

Exemple Répéter
'corriger les copies'
Jusqu’à (il n'en reste plus')

Dans ce format l'action est exécutée au moins une fois, c'est à dire au début
Pour la même action la condition de la 2è forme est la négation de la condition de la
1ème forme
Par exemple pour la 'correction des copies' la 1ème Forme est :

Tanque 'Il Ya des copies’ faire

'corriger les copies'
Fin tanque
B. Pour :

Cette forme est utilisée lorsque l'on sait le nbre de fois dont l'action est exécutée.
Dans ce cas le nbre d'exécution est contrôlé par un paramètre par exemple I.
Soit D la valeur initiale de I.
F la valeur finale de I.
La syntaxe de cette forme de répétition est alors
Pour I allant de D à F par pas P faire
Action
Fin Pour
P : est appelé le pas (step), c'est la constante que l'on ajoute à I à chaque étape.
Exemple :
Pour I allant de 2 à 18 par pas de 4 faire
Action
Fin Pour
L’action est exécutée pour la valeur suivante de I :
I : 2,6,10, 4, 18.

Remarque :
Généralement l'action est une fonction du paramètre I
A) La valeur finale peut ne pas être atteinte
Exemple : Pour I allant de 5 à 13 par pas de 3 faire
Action
Fin Pour
Les valeurs de I pour lesquelles l'action est exécutée I : 5, 8, 11
B) Le pas est pris au départ égale à 1
Exemple Pour I allant de 8 à 15 faire
Action
Fin Pour
Les valeurs prises pour i sont : I = {8,10,11,12,13,14,15}
Chapitre 2 : Les tableaux
I. Définition :
Un tableau est une structure de données ayant
 Un nom, c’est son identifiant
 Un type, c’est le type commun à tous ses éléments
 Une taille, c’est le nbre d’éléments contenues dans le tableau
 Une dimension, c’est-à-dire le nbre de paramètre entiers permettant d’accès à
chaque élément du tableau
Remarque : on s’intéressera ici aux tableaux de dimension 1 et 2

A. Tableaux de dimension 1
1. Exemple
TAB : {18,-3,20,10,40,25}
Nom : TAB
Taille N=6,
Type : entier
2. Primitive d’accès
Si i £ [1,6], TAB (i) est le 1 er élément
Si i non £ [1,6], TAB (i)est Indéterminé

TAB (1) = 18, TAB (2) = -3; TAB (3) = 20

TAB (4) = 10, TAB (5) = 40; TAB (6) = 25
3. Définition

Type TAB = tableau [N] : d’auteur

Défini un tableau de table N à valeur entrées

4. Applications
Il Ya plusieurs applications, elles s’appuient sur le parcours
_Création
_Somme
_Eclatement
_Monotones etc.
Exercice1 : Crée un tableau TAB de table N à partir des valeurs Val saisir
Algorithme :
Var I, N, Val : entier
Procedure Cree TAB (et TAB [N])
Debut
Affecter (‘ Donner la taille N’)
Saisir N
Si (N<= 0) alors
Affecter (‘Taille incorrecte’)
Sinon
Pour i allant de 1 à N faire
Affecter (‘ saisir la valeur du 1er element’)
Saisir Val
TAB (i)  Val
Fin Pour
Fin Si
Fin Cree-TAB

Exercice2 : Somme de deux tableaux TAB1 et TAB2 de même dimension et de même type
Algorithme :
Procedure Somme (données TAB1[N], TAB2[N] ; resultat TAB[N])
Var i : entier
Debut
Pour I allant de 1 à N faire
TAB(i)  TAB1(i) + TAB2(i)
Fin Pour
FIN Somme
Exercice3 : Eclater un tableau TAB [N] en 2 autres tableaux
-TAB1[N] qui contient la valeur impaire de TAB, les valeurs paires remplacées par 0
-TAB2[N] qui contient les valeurs paires, les valeurs impaires remplacées par 0
Exemple :
TAB : {18,9,31,10,40,7,12,19}
TAB1 : {0,9,31,0,0,7,0,19}
TAB2 : {18,0,0,10,40,0,12,0}
Procedure Eclat (donner TAB[N], resultat TAB1[N], TAB2[N])
Var i : entier
Debut
Pour i allant de 1 à N faire
Si (TAB(i) mod 2 = 0) alors
TAB2(i)  TAB(i)
TAB1(i)  0
Sinon
TAB1(i)  TAB(i)
TAB2(i)  0
Fin SI
Fin Pour
FIN
Exercice 4 : Recherche d’1 valeur dans un tableau TAB sont
TAB= {18,40,10,30,-2 ,60,20}
Valmin = -2, Posmin = 5
Procédure valeur-minimale (donnee TAB [N] ; resultat valmin, Posmin : entier)
Var i, Min, Pos : entier
Début
Pos  1
Min  TAB (1)
Pour i allant de 2 à N faire
Si (TAB(i) < Min) alors
Min  TAB (2)
Pos  i
 Fin Si
Fin Pour
ValMin Min
PosMin Pos
FIN

Exercice5 : Tri d’un tableau (croissant ou décroissant). Il ‘agit de la mise en mode des
l’éléments dans l’ordre croissant ou décroissant
Exemple
TAB = {18,5, 49,- 2, 20 ,30 ,49}
Trié en croissant il devient
TAB = {-2,5,10,15,18,20,30,49}
Il Ya plusieurs méthode de tri
 Tri par partage
 Tri par permutation
Nous nous intéressons ici au tri par permutation compte tenu de son efficacité.
Principe soient i et 2 entiers
Si i < j et TAB(i) > TAB(j) / désordre
-----> permute TAB(i) et TAB(j) comme suit :
Sauv TAB(i)
TAB(i) TAB(j)
TAB(j) Sauv
Algorithme : Parcourir le tableau TAB comme suit
-Comparer chaque élément TAB (i) à tous ses suivants TAB(j) avec j > i
Si l’ordre n’est pas en croissant permuté Tab(i) et TAB(j)
Procédure Tri_permut (données résultats TAB(N)
Var i, j, Sauv: entire
Debut
Pour I allant de 1 à N-1 faire
Pour j allant de i+1 à N faire
 Si (TAB(i) > TAB(j)) alors
Sauv TAB (i)
TAB (i) TAB(j)
TAB (j) Sauv
Fin Si
Fin Pour
Fin Pour
Fin Tri-permit

Monotonie dans un tableau de Dimension 1 à Valeurs Entiers

1.) Définition monotonie croissants (décroissants)

Il s’agit du nbre de rupture de l’élément consécutif croissants (décroissants) contenus dans

le tableau
Exemple
Soit Tab le tableau svt à valeurs entières
Soit TAB : 18, 4, 13, 20, 10, 17, 5, 40, 60, 85, 25, 30, 12, 19, 32
Il y’a 6 monotonies croissants à savoir :
18

4, 13, 20

10, 17

5, 40, 60, 85 la plus longue

25, 30
12, 19, 32
Remarque :
a) Pour tout tableau non vide TAB il y’a au moins une monotonie croissante
b) Pour tout indice i entier avec i < N (N nbre d’élément contenu dans le TAB)
Si TAB(i) > TAB (i+1) on a une nouvelle monotonie qui apparait. Donc si CT désigne le
compteur des monotones, on a l’instruction svtes :
 Si TAB(i) > TAB(i+1) alors
CT CT+1
Fin Si

*CT sera initialiser à 1 car il y’a moins une monotonie dans le tableau non vide
Travail demandé
Ecrire l’algorithme svt qui compte le nbre NB.Mono_croiss de monotonies
croissantes, contenue dans le tableau TAB
Fonction NB.Mono_croiss (donnees TAB(N)) : entier
Var i, CT : entier
Debut
Si (N>0) alors
CT 1
Pour i allant de 1 à N-1 faire
Si (TAB(i) >TAB(i+1)) alors
CT CT+1
Fin Si
Fin Pour
NB.mono_croiss CT
Sinon
Afficher (‘’Table vide’’)
Fin Si
Fin NB.Mono_croiss
Le plus long élément si (N > 0)
Exercice 7 : Ecrire l’algorithme svt qui détermine le nombre d’élément NBELT et la POSIT de
la plus longue monotone croissante du tableau TAB
_Dans l’exemple precedent NBELT: 4, POSIT:7.
Il s’agit de la monotone : 5, 40, 60, 85
Procedure START_Mono_Croiss (donnee TAB[N]; resultat NBELT, POSIT: entier)
Var il, ig, CTl, CTg, i, j: entier;
Mono : booleen
Debut
 Si (N > 0) alors
Ig 1
CTl 1
CTg 1
Pour i allant de 1 à N-1 faire
il i
Mono vrai
j i
Tanque (mono = Vrai) et (j< N-1) faire
Si (TAB(j) <= TAB(j+1)) alors
CTl CTl+1
;j j+1
Sinon
, mono Faux
Finsi
Fin Tanque %comme on a un champ de monotone%
Si (CTl > CTg) alors
CTg CTl
; ig il
Fin Si
;i j
Fin Pour
NBELT CTg
POSIT ig
Sinon
Afficher (‘’tableau vide’’)
Finsi
Fin START_Mono_Croiss

2.) Les Tableaux de dimensions 2 Matrice

A.)Définition
Il s’agit de tableau dont l’accès aux l’éléments se fait par l’intermédiaire de deux paramètre i
et j.
Par exemple : i est appelé Ligne, j est appelé colonnes
 S’il y’a l lignes et C colonnes, la taille est L *C
 Le type de tableau est le type commun à tous les éléments
 Son nom Mat est son identifiant
Un tel tableau à valeur entières est défini par :

Type Mat : Tableau [L, C] : entier

Remarque
a.) Matrice carrée d’ordre N
Il s’agit de matrice dont le nombre de ligne L est égal au nombre de colonne égal à N
L=C=N
b.) Les valeurs des matrices peuvent être autres des entiers, des caractères, par
exemple.

3.) Primitives élémentaires

Soit Mat [L, C] une matrice de L ligne, C Colonnes si I € [1, L] et j € [1, C] alors Mat [i, j] est
l’élément de la i ème ligne et la j ème colonne

Exemple : Mat 12, -3, 10, 5

11, 20, 30, 17
4, 0, 18, 7
1ligne : Mat [1, 1] = 12, Mat [1, 2] = -3, Mat [1, 3] = 10, Mat [1, 4] = 5
2ligne : Mat [2, 1] = 11, Mat [2, 2] = 20, Mat [2, 3] = 30, Mat [2, 4] = 17
3ligne : Mat [3, 1] = 4, Mat [3, 2] = 0, Mat [3, 3] = 18, Mat [3, 4] = 7
Remarque :
Diagonales et médiane dans une matrice carrée
Schéma : Diagonale Secondaire
Xxxxxxxxxxxxxx Médiane principales

Médiane secondaire Diagonale principale

4.) Application
Il s’agit d’algorithme utilisant cette structure de donnée comme donnée
Exercice1 :
Création d’une matrice Mat [L, C] à partir de la saisie de valeur Val
Procedure creation_Mat (resultat Mat [L, C])
Var I, j, Val: entire
Debut
Afficher (‘Saisir les lignes et les colonnes’)
Saisir L, C
Si ((l<=0) ou (C<=0)) alors
Afficher (‘’Paramètre incorrectes ‘’)
Sinon
Pour i allant d 1 à L faire
Pour j allant de 1 à C faire
Afficher (‘’ saisir la valeur’’)
Saisir Val
Mat (i, j) Val

Fin Pour

Fin Pour

Fin Si

Fin Crée_Mat

Remarque : Création d’une matrice à partir d’un tableau de dimension 1 et réciproquement

I) d’une matrice Mat à un tableau TAB

Exemple : Mat 12 4 9 11

6 0 14 -2

20 18 3 5

Dans un parcours ligne /ligne on obtient le Tab suivant

TAB = {12, 4, 3, 11, 6, 0, 14, -2, 20, 10, 3, 5}

ii) D’un tableau TAB(N) on peut obtenir 2 matrices Mat si l’on ne précis pas le nbre de ligne.

Exemple :

Tab : {17, 10, 40, -5, 20, 12, 13, 18} à N= 8 éléments

On peut lui associer 2 matrices

Mat1 [L1, C1] et Mat2 [L2, C2] avec L1*C1 = L2*C2 = 8

Prenant L1 = 2, C1 = 4 et L2 = 4, C2 = 2
Mat1 : 17 10 40 -5 Mat2 : 17 10

20 12 19 18 40 -5

20 17

19 18

Exercice2 : Eclatement d’une matrice Mat [L, C] selon des critères

Eclater Mat2 [L, C] qui contient les éléments pairs de numéro de ligne et de numéro de colonnes
paires, les autres remplacés par 0

Mat1 [L, C] qui contient les éléments impairs de numéro de ligne et de colonnes impaires, les autres
remplacés par 0

RMAT [L, C] qui contient ce qui ne répondent pas aux critères précédant, ceux qui répondent sont
remplacés par 0

Exemple : Mat = 12 17 13 10 29 20

11 32 15 40 18 4

9 43 31 2 25 8

Mat1 = 0 0 0 0 0 0 Mat1 0 0 13 0 29 0

000000 0 0 0 0 0 0

000000 9 0 31 0 25 0

Mat2 = 0 0 0 0 0 0 Mat2 0 0 0 0 0 0

000000 0 32 0 40 0 4

000000 0 0 0 0 0 0

RMAT = 0 0 0 0 0 0 RMAT 12 17 0 10 0 20

000000 11 0 15 0 18 0

000000 0 43 0 2 0 8

Procedure Eclat ( donne Mat [L, C] ; resultat Mat1 [L, C], Mat2 [L, C], RMAT [L, C])

Var I, j : entier

Debut

Pour i allant de 1 à L faire

Pour j allant de 1 à C faire

Mat1 [L, C] 0
 Mat2 [L, C] 0

RMAT [L, C] 0
FinPour
FinPour
Pour i allant de 1 à L faie
Pour j allan de 1 à C faire
Si ((Mat[i, j] mod2 = 0) et (i mod2 = 0) et (j mod2 = 0)) alors
Mat2[i, j] Mat (i, j)

Sinon

Si ((Mat[i, j] mod2 = 1) et (i mod2 = 1) et (j mod2 = 1)) alors

Mat1[i, j] Mat (i, j)

Sinon

RMAT (i, j) Mat (i, j)

Finsi

Fin Si

Fin Pour

Fin Pour

Fin Eclat

Exercice3 : Valeur minimal d’un élément d’une matrice Mat (l, c)

Algo : initialiser le minimum Mat (1,1) et faire le parcours

Procédure ValMin ( donnee Mat[L, C] : entier)

Var i, j, Min : entier

Debut

Si ((l<=0) ou (C<=0)) alors

Afficher (‘’Dimension incorrecte’’)

Sinon

Min Mat (1,1)

Pour i allant de 1 à L faire

Pour j allant de 1 à C faire

Si ( Mat (i, j)<Min) alors

Min Mat (i, j)

 Fin Si

Fin Pour

Fin Pour

ValMin Min

Fin Si

Fin ValMin

Exercice4 : Ecrire l’algorithme suivant et remplace chaque élément d’une ligne Mat par La valeur max
des éléments de la ligne

Procedure remp_VamMax (donne_resultat Mat[L, C]

Exemple : Mat = 12 17 13 10

11 32 18 40

9 43 31 2

Mat = 17 17 17 17

40 40 40 40

43 43 43 43

Procedure Max_ligne (donne_resultat Mat (L, C))

Var i, j, Max : entier

Debut

Pour i allant de 1 à L faire

 Max Mat (i, 1)

Pour j allant de 1 à C faire

Si (Mat (i, j) > Max) alors

Max Mat (i, j)

Fin Si

Fin Pour

Pour j allant de1 à C faire

Max (i, j) Max

Fin Pour

Fin Pour

Fin Max_ligne

Chapitre 3 : Les piles

I) Introduction
Il s’agit d’une structure de données pour laquelle les données sont gérées en LIFO [last in,
first in] c’est-à-dire dernier enregistré, premier ressorti.
Ce type de gestion est utile dans la résolution de plusieurs problèmes tel que

 L’évaluation des expression arithmétiques logiques ou pour poursuivre une opération

c’est la dernière valeur mémorisée qui est ressortie pour continuer les calculs
 Le parcours de certaines structures de données ou pour se souvenir du chemin
parcouru ou le stocke lors des parcours les points traversés dans une structure de
données de type PILE.
Pour bien maitriser la gestion de cette structure de données on peut l’identifier à une pile de
livres ou pour maintenir la pile en équilibre
 Les ajouts se font au sommet
 Les suppressions à partir du sommet dont en mode LIFO

Représentation : schéma

Une pile est généralement représentée sous le format suivant :

Sommet
30
-----
10
40
15
Base
P

Ou P est la pile
Base et Sommet sont des indices Bases
Base est l’indice du 1e élément de la pile.
Sommet est l’indice du dernier element de la pile.
Remarque : La représentation de données par un tableau est une représentation dite
STATIQUE c’est à dire que la taille est fixée.
Ce type de représentation est moins intéressantes que les représentations dites chaînée,
c’est-à-dire celle qui utilise des pointeurs, appelée représentation DYNAMIQUE.
Après l’étude de la structure de données les listes linéaires, on représentera la
représentation dynamique de la structure de données Piles.

II) DEFINITION ET PRIMITIVES

ELEMENTAIRES
Dans la représentation par tableau d’une pile P on a associé le schéma svt :
 Sommet

---

Base
P
Remarque : on peut réduire la gestion d’une pile P à la valeur du sommet par exemple si la
pile est de taille N (Taille du tableau associé)
 Elle est vide si Sommet = 0
 Elle est pleine si Sommet=N

1.) Définition
Une pile P de taille N gérée sous forme de Tableau est définie par :

Type P : Tableau(N) : entier

Sommet = 0, ----, N

Où le sommet est le paramètre de qui permet d’accéder aux éléments de la pile P.

Remarques :
A) Un seul élément est accessible à tout instant c’est le dernier élément qui est la
position SOMMET
B) La pile est vide si SOMMET = 0
C) La pile est pleine si SOMMET = N
D) Les éléments d’une pile doivent tous être du même Type. Ils peuvent être des entiers
Exemple : P=
Sommet= 3

S
K
P

2.) Primitives élémentaires

Il s’agit d’actions élémentaires qui permettent d’effectuer des opérations sur cette structures
de données. Il s’agit de
 Initpilevide qui initialise une pile à la pile vide
 Pilevide qui vérifie si une pile est vide
 Pilepleine qui vérifie si une pile est Pleine.
 Empiler qui permet d’ajouter un élément dans une pile
 Depiler qui permet de supprimer un élément d’une pile
 Soit P une pile et Val une valeur, sommet l’indice associé à la pile.

a) INITpilevide
Procedure INITpilevie (donnée_resultat P : pile)
Var Sommet : entier
Debut
Sommet 0
FIN INITpilevide

b) PileVide
Fonction PileVide (donnée P : pile)
Var Sommet : booleen
Debut
Si (Sommet = 0) alors
PileVide vrai
Sinon
PileVide faux
FinSi
FIN PileVide

c) Pilepleine
Fonction Pilepleine (donnée P : pile) : booleen
Var Sommet : entier
N : entier % taille de la pile %
Debut
Si (Sommet = N) alors
Pilepleine Vrai
Sinon
Pilepleine Faux
FinSI
Fin PilePleine

d) Empiler
Procedure Empiler (donnée P : pile ; val : type_valeur ; resultat P : pile)
Var Sommet : entier
Debut
Si (Pilepleine(p) = Vrai) alors
Afficher (‘pas d’espace’’)
Sinon
Sommet sommet+1
P (Sommet) Val
FinSi
FIN Empile

e) Depiler
Procedure Depile (donnée P : pile ; resultat P : pile, Val : Type_valeur)
Var Sommet : entier
Pilevide : booleen
Debut
Si (Pilevide (p) = Vrai) alors
Afficher (‘La pile est vide’)
Sinon
Val P(Sommet)
Sommet Sommet - 1
FinSi
Fin Depiler
Remarque
Appel des primitives
Dans leurs utilisations on réduira dans ce cours les appelles comme suit :
Soit P une pile, Val une valeur
InitPile (P)
PileVide(P)
Pilepleine(P)
Empiler(P)
Depiler (P, Val)
 III) APPLICATIONS
Il s’agit d’algorithmes utilisant des primitives pour gérer les informations manipulées par une
pile
1.) Création d’une pile
Il s’agit de mettre des informations dans une pile à partir de données

 Saisie
 Provenant d’une autre structure de données(tableaux) par exemple
Ecrire l’algorithme suivant qui crée une pile P de Type entier et de taille N à partir de
Valeur Val saisies
Procedure Crée_Pile (donnée N : entier ; resultat P : pile)
Var Val : entier
Debut
Initpile (P)
Pour i allant de 1 à N faire
Afficher (‘ donner une valeur’)
Saisir Val
Empiler (P, Val)
Fin Pour
FIN Crée_Pile
2.) Somme e 2 piles P1 et P2
P1 et P2 doivent être de même taille et de même type
Exemple : P1 = P2= svg P=
20 17 37
-5 30 25
50 -15 35
8 22 30
résultat Depile empile
Procedure Somme (données P1, P2 : Pile ; resultat P : pile)
Var Val1, Val2, Val : entier SVG : Pile
Debut
Initpilevide (SVG); Initpilevide (p)
Tanque (PileVide (P1) = Faux) faire
 Depiler (P1, Val1)
Depiler (P2, Val2)
Empile (SVG, Val)
FinTanque
Tanque (PileVide (SVG) = Faux) faire
Depiler (SVG, Val)
Empiler (P, Val)
FinTanque
FIN Somme
3.) Eclatement d’une pile P en 2 piles P1 ET P2 de même taille et de même type
Ecrire l’algorithme suivant qui éclate une pile P à la valeur entières en 2 piles P1 et P2
P1 contient les valeurs impaires de P, positionnées aux mêmes endroits, les valeurs paires
remplacées par 0
P2 contient les valeurs paires de P, les valeurs impaires remplacées par 0
Exemple P= P1= P2=
7 7 0
10 0 10
8 0 8
19 19 0
11 11 0
Procédure Eclat (donnée P : pile ; résultat P1, P2 : pile)
Var Val : entier
SG1, SG2 : pile
Const zero = 0
Debut
Initpilevide (P1), Initpilevide (SG1), Initpilevide (P2), Initpilevide (SG2)
Tanque (PileVide(P)=faux) faire
Depiler (P, Val)
Si (Val mod2=0) alors
Empile (SVG2, Val)
 Empile (SVG1, zero)
Sinon
Empile (SVG1, Val)
Empile (SVG2, zero)
Fin Si
FinTanque
Tanque (Pilevide (SVG1) = faux) faire
Depile (SVG1, Val)
Empile (P1, Val)
FinTanque
Tanque (Pilevide (SVG2) = faux) faire
Depile (SVG2, Val)
Empile (P2, Val)
FinTanque
Fin eclat
4.) Trier les éléments d’une pile P à la valeurs entiers principe

Soit P une pile la trier en croissant

Pour Cela
a) Transférer les éléments de la pile dans un tableau TAB
b) Trier ce tableau en croissant
c) Transférer les éléments du tableau TAB Du début à la fin dans la pile P
Exemple :
P=

30
50
40
-5
8

1- Étape transfert dans TAB

TAB : 30, 50, 40, -5, 8
2- Tri de TAB en croissant TAB : -5, 8, 30, 40, 50
 50
40
30
8
-5

3- Transfert de TAB dans la pile P du début à la fin

i 0
Tanque (PileVide (P)= faux)
Depile (P, Val)
i i+1
Tab(i) Val
Fin Tanque
N i
5.) Recherche d’une valeur dans une pile P trié en croissant de la base en sommet
Remarque
_On continue la recherche

 Si l’élément courant de la pile est supérieur à la valeur recherchée

_On s’arrête

 Si l’on rencontre l’élément recherché où

 Si l’on rencontre un élément plus petit que l’élément recherché où
 Si la pile devient vide
Fonction Recherche (donnée P : PILE ; Val : entier)
Var Valx : Entier
Trouve : booleen
Debut
Trouve faux
Tanque (PileVide (p) = faux) et (trouve= faux)) faire
Depile (p, valx)
Si (valx > val) alors
Pilevide(p) Vrai %Pour sortir de la boucle %
Sinon
 Si (valx <= val) alors
Trouve Vrai
FinSi
Fin Si
Recherche trouve
FIN RECHERCHE
CHAPITRE 4 : les structures de données : files
I.) Introduction
Il s’agit d’une structure de données conque sous le concept FIFO (first in, first out) qui signifie
premier stocker, premier ressortie. C’est que nous appelons traditionnellement la queue.

Nous étudierons par la suite les structure files particulières appelées files avec niveau de priorité,
c’est-à-dire une file dans laquelle on peut extraire d’autre files. Par exemple des personnes devant
un guichet on peut associer des sous-groupes tel que :

 Les vieux
 Les femmes
 Les enfants

Schéma associé à une file simple

Nous travaillons sur le schéma svt :

Suppression

………….
Insertion

On désignera par

TETE l’élément qui est le plus en avant dans la file

QUEUE le dernier élément de la file

Il s’agit ici d’une représentation CONTIGUE d’une file, c’est-à-dire une représentation sous forme de
tableau d’une file dite simple comparée avec les files avec niveau de priorité. Il y’a un autre type de
représentation appelé la représentation dynamique ou chaîne qui utilise la notion de pointeur.

On s’y introduira une fois avoir défini ce type de représentation dans les chapitres les listes linéaires.

II.) Définition et primitives élémentaire de la représentation contigue

1.) Définition
Une File P contenant N éléments est définie par

Type P = tableau (N) de type valeur

TETE, QUEUE : O, …….., N

Où TETE et QUEUE sont des paramètres qui désignent

 L’indice où est positionné le premier élément de la file

 L’indice où est positionné le dernier élément de la file

2.) Primitives élémentaires

Soit P une file de taille N

a) F (TETE) est la valeur de l’élément de tete si TETE <> 0

b) F (QUEUE) est la valeur de l’élément de queue si QUEUE <> 0
c) FileVide (P) = Vrai si TETE = QUEUE = 0
d) FilePeine (P) = Vrai si QUEUE = N
 III.) Applications
Il s’agit d’ajout et de suppression d’élément dans une file F de taille N (contenant N éléments)

1.) Ajout d’élément

a) Exemple

B K L F C

TETE QUEUE

Situation initiale

Ajouter R et D : action

B K L F C R D

TETE QUEUE

Situation Finale

b) Algorithme

P en commentaire désigne la personne

Procédure Ajout (donne F : file ; val : type-value ; TETE, QUEUE : entier ; resultat F : file)

Const DIM : entier %taille de la file%

Debut

Si (QUEUE >= DIM) alors % si la dernier E de la f est + grand ou égale à la taille%

Afficher (‘file pleine’) %cela veut dire que l’espace allouer est dépassé don la file est plaine%

Sinon

Queue Queue+1 %le d E de la F reçoit une d E + une autre p %

F (QUEUE) Val % donc la file reçoit la valeur de la dernière p%

Si (TETE = 0) alors % s’il y’a personne à la tête alors tête reçoit la premier P%

TETE 1

Fin Si

Fin Si

Fin Ajout

Cas particulier : File circulaire

Il s’agit de file soumise à la règle de gestion suivant :

Si l’on désire ajouter une valeur et que

  La queue est à la dernière position et que
 Des positions sont vides en avant

On occupe ses positions en avant

Exemple

TETE QUEUE

B o n j

Situation initiale

Ajouter OUR

Action

o u r B o n j

QUEUE TETE

Situation finale

Algorithme

Procédure Ajout (donne F : file ; val : type-value ; TETE, QUEUE : entier ; resultat F : file)

Const DIM : entier %taille de la file%

Debut

Si (QUEUE = DIM) alors

QUEUE 1

Sinon

Queue Queue + 1

Fin Si

Si (TETE = Queue) alors

Afficher (‘file pleine’)

Sinon

Si (TETE = 0) alors

TETE 1

Fin Si

Fin Si

Fin Ajout
 2.) Suppression d’élément

Exemple

Algorithme

Procedure sup (donne F : file ; TETE, QUEUE : entier ; resultat F : file, val : type-valeur)

Debut

Si (TETE = 0) alors

Afficher (‘file vide’)

Sinon

Val F (TETE)

Si ( TETE = QUEUE) alors % c’est-à-dire qu’il y’a au moins un élément dans la file donc init à 0%

TETE 0

QUEUE 0

Sinon % s’il y’a r on ajoute nos éléments dans la file%

TETE TETE + 1

Fin Si

Fin Si

Fin Sup

Cas particulier : File circulaire

Procedure sup (donne F : file ; TETE, QUEUE : entier ; resultat F : file, val : type-valeur)

Debut

Si (TETE = 0) alors

Afficher (‘file vide’)

Sinon

Val F (TETE)

Si (TETE = QUEUE) alors % c’est-à-dire qu’il y’a au moins un élément dans la file donc o init%

TETE 0

QUEUE 0

Sinon % s’il y’a r on ajoute nos éléments dans la file%

Si (TETE = N) alors
 TETE 1

Sinon

TETE TETE + 1

Fin Si

Fin Si

Fin Si

Fin Sup

IV.) Files particulières : files avec niveau de priorité

1.) Remarque
Dans ce type de file à chaque élément est associé une priorité qui est un entier.

Un élément un plus prioritaire qu’un autre si sa priorité est inférieure à celle de l’autre.

2.) Exemple
(P1, 10), (P2, 8), (P3, 4), (P4, 10) sera exécuté dans l’ordre suivant : P3, P2, P1, P4

A priorité égale l’exécution se fait dans l’ordre

3.) Représentation
A Chaque niveau de priorité est associé à une file. Tous les éléments d’une file étant de même
priorité, un processus possède un autre s’il est inséré avant, lus dans la même file

Ainsi la file principale File est composée de plusieurs sous files.

Soit Max = N la priorité maximale de la file principale FILE

Dans ce paragraphe on s’intéresse à la représentation statique c’est-à-dire par tableaux.

La file File est représentée comme suit :

……

Priorité (Pmax)

……

TAB ((Pmax), DIM)

…….
TETE (Pmax)

……

QUEUE (Pmax)

DEFINITIONS :

Pmax est la priorité maximale

DIM est la taille d’une file (nbre d’élément que peut contenir une sous-file)

TAB = Tableau (Pmax, DIM) est le tableau contenant dans chaque ligne i de Priorité(i) les éléments de
cette priorité ayant un maximum DIM éléments

TETE = tableau (Pmax) est telle que pour chaque ligne i, TETE(i) est l’élément de tete

QUEUE= tableau (Pmax) est telle que pour chaque ligne i, QUEUE (i) est l’élément de QUEUE

Exemple soit une file FILE avec un niveau de priorité contenant des éléments ayant la priorité

Pmax = 5 svt : (R,5) (A,6), (C,3), (B,7), (F, 5), (E, 3), (D, 5), (K, 7), (H, 4), (J, 6), (L, 3), (P, 4), (L, 7), (X, 4),
(Y, 6), (T, 3), (M,3)

Remarque : La taille de chaque file est fixée au maximum à 10

Représentation

1 3 c E L T M 2 6

2 4 H P X 1 3

3 5 R F D 4 6

3 6 A J Y 3 5

5 7 B K L 1 3

Priorité TAB (5, 10) TETE (5) QUEUE (5)

4.) Algorithme de suppression d’ajout dans une file avec niveau de priorité
a.) Algorithme de suppression

Procedure sup (donnes Pmax, DIM : entier, TAB (Pmax, DIM) ; TETE(Pmax), QUEUE (Pmax) ;
resultat TAB (Pmax, DIM), TETE(Pmax), QUEUE(Pmax))

Var Trouve : booléen % vrai si l’on trouve l’élément à supprimer%

Priorité : entier

Debut

Trouve faux ::

Priorite 1

Tanque ((Priorite < Pmax) et (Trouve= faux)) faire

Si (TETE (Priorite) > 0) alors

Trouve vrai

Val TAB (Priorite, TETE(Priorite))

Si (TETE (Priorite) = QUEUE(Priorite)) alors

TETE (Priorite) 0;

QUEUE (Priorite) 0

Sinon

Si (TETE (Priorite) = DIM) alors

TETE (Priorite) 1

Fin Si

Fin Si

Fin Si

Fin Tanque

Fin

a) Suppression

On supprime l’élément de tête de la file ayant la faible priorité

b) Ajout

Pour ajouter une valeur Val dans la file il faut connaitre la priorité PV associée à cette valeur.
Ainsi dans la sous liste de priorité Pv l’ajout se fera de façon classique c’est-à-dire à partir de la
queue de cette sous liste

Exemple:

6 K S V U 2 4

17 H 0 0

20 U A R T P 3 6

35 B N C E F 1 5

42 L M S W G 4 7

Priorité Tab TETE QUEUE

Ajouter les valeurs Val dont la priorité est dans le couple (Val, Pv) ;

(H, 17), (L, 42), (P, 20), (U, 6) on obtient la mise à jour écrite en bleu

Travail demandé :

Ecrire l’algorithme suivant qui ajoute une valeur Val de priorité Pv dans la file représentée par les
tableaux

TAB (Pmax, DiM)

TETE(Pmax)

QUEUE(Pmax)

Procedure Ajout (donne Val, Pv : entier, TAB (Pmax, DIM) ; TETE (Pmax), QUEUE (Pmax) ; resultat
TAB (Pmax, DIM), TETE, QUEUE)

Debut

Si (Pv <= Pmax) alors

Si (QUEUE(Pv) = DIM) alors

Position 1;

Sinon

Position QUEUE (Pv) + 1

Fin Si

Si (Position = TETE (Pv)) alors

Afficher (‘file pleine’)

Sinon

TAB (Pv, Position) Val

QUEUE(Pv) Position

Si TETE (Pv) = 0) alors

TETE (Pv) 1

Fin Si

Sinon

Afficher (‘Priorité non admise’)

Fin Si

Fin Ajout
Chapitre 4 : Les listes linéaires
I.) Introduction
Les structures de données sont généralement introduites à partir de la formalisation des cas
pratiques qui laissent entrevoir généralement un certain nbre de problèmes qu’il revient à
formaliser.

Concernant la structure de données ‘Liste Linéaire’ le concept à trouver ses origines Dans ce qui suit
à savoir :

 La notion du voisin (successeur) logique et de voisin (successeur) physique

1.) Exemple
Considérons les deux types de tableaux svt

a.) Tableaux à valeurs entière TAB

Exemple

TAB= {15, -7, 40, 18, 10, 30}

Si l’on s’intéresse au tableau trié en croissant associé on a ceci :

Le successeur physique de 15 est -7

Le successeur logique est 18 etc…

b.) Tableau à valeur structurées

Exemple :

NUM Description Successeur

Nom Prénom
1 KANE BINETA 4
2 SY AWA 0
3 DIOP OMAR 1
4 NDIAYE FATOU 7
5 ANNE OUSMANE 8
6 DIOP LAMINE 3
7 SENE ANDRE 2
8 BA MOUSSA 6
TETE

 Suivant 0 (NULL) signifie Fin de la liste.

 Le tableau Suivant est la considération sous forme ordonné du tableau. Ce tableau
supplémentaire (colonne) a été introduit pour trier le tableau initial TAB contenant
uniquement les couples (Nom, Prénom)
 Le paramètre TETE désigne le point de départ du tableau dans sa version ordonnée
 2.) Nouveaux concepts
Pour prendre en compte certains éléments dans la formulation de ces cas pratiques on a introduit
des nouveaux concepts comme la colonne Suivant dans l’exemple précédant.

Conclusion

A La structure d donnée classique Tableau, on a associé un autre tableau Suivant qui permet de
représenter cette nouvelle structure de donnée appelée Liste Linéaire.

Les listes Linéaires ont fait apparaitre les concepts suivants

3.) Voisin Physique et Voisin Logique

Le voisin Logique est l‘adresse physique de successeur logique. Dans l’exemple précédant

Le voisin physique de KANE BINETA est SY AWA

Son voisin Logique est NDIAYE FATOU

II.) Représentation et primitives élémentaires associées

1.) Représentation : Liste linéaire monodirectionnelle
Chaque élément P d’une liste monodirectionnelles est représenté par un couple

Valeur Suivant

Suivant peut être représenté par :

 Un tableau, il s’agit de la représentation par tableau (dite Statique) d’une liste linéaire
 UN pointeur il s’agit de la représentation chainée (dite dynamique) d’une liste linéaire

a.) Représentation par tableau

Dans cette représentation

 VALEUR est un tableau contenant les valeurs (toutes de mm types) de la liste

 SUIVANT est le tableau de mm Taille contenant les adresses du successeur de chaque
élément de la liste.

Soient N la taille commune de ces tableaux NULL (= 0) la fin de la liste il s’agit du dernier élément qui
n’a pas de successeur

Ainsi une liste linéaire L représentée par des tableaux de taille N à valeurs entières par exemple sera
définie par

Type VALEUR = tableau (N) d’entiers

Suivant = tableau (N) d’entiers

Remarque : Inconvénient

L’inconvénient majeur de cette forme de représentation réside dans l’aspect statique des structures
de données, c’est-à-dire la taille est fixée.
La représentation Suivant appelée représentation dynamique résous cet inconvénient

c.) Représentation chainée : notion du pointeur

Il s’agit de la représentation suivante dont chaque élément existant P, c’est-à-dire P<> de NULL est
représenté par un couple (VALEUR, LIEN)

VALEUR est la valeur associée à P

LIEN est l’adresse du successeur de P

Schéma

VALEUR LIEN
Où lien est représenté par une flèche ( )

Exemple le tableau svt

TAB : 15, 8, 40, -3, 30, 50, 10 sera représenté par :

TETE

15 8 40 -3 30 50 10 ou signifie NULL(FIN)

Le tableau trié en croissant modifie la TETE et le LIEN par suit :

TETE

15 8 40 -3 30 50 10

PRIMITIVES élémentaires

Soit P un élément de la liste linéaire L avec P <> NULL

i) Valeur

P .VALEUR est la valeur associé à P

ii) Lien

P . LIEN est l’adresse du successeur de P

Exemple

P1 P2 P3

10 7 15

P1 .VALEUR = 10 ; P2 .VALEUR = 7 ; P3 .VALEUR = 15

P1 . LIEN = P2 ; P2 . LIEN = P3 ; P3 . LIEN = NULL

Combinaison de valeur et lien

i) (P. LIEN). VALEUR Est la valeur associée au suivant de P s’il existe P. LIEN<>NULL
ii) (P. VALEUR). LIEN N’est pas définie car on ne connait pas le successeur d’une valeur
Exemple

P1 P2 P3

10 4 20

(P . LIEN) . VALEUR = P2. VALEUR = 4

(P . LIEN) . VALEUR = P3.VALEUR = 20

(P . LIEN) . VALEUR est indefini car P3.LIEN= NULL

NB : pour ne pas perdre la liste il faut toujours sauvegarder le 1 e élément

III.) Application
1.) Remarque
Il s’agit d’algorithme utilisant les primitives élémentaires définies précédemment à savoir VALEUR et
LIEN dans des exercices généralement de parcours de liste linéaires.

La gestion dynamique qui s’intéresse surtout à la création et à la mise à jour sera étudiée plus tard
une fois depuis définis les primitives élémentaires associées à cette gestion.

L1 : tete de la liste

Exercices d’Applications

Exercice1 : Nombre NB_ELT d’élément d’une liste linéaires L1 de type L.

Ecrire l’algorithme

Fonction NB_ELT (donnée L1 : L) : entier %qui détermine le nombre NB_ELT d’élément%

Var L11 : L

CT : entier

Debut

L11 L1

CT 0

Tanque (L11<> Null) faire

CT CT+1

L11 L11 . LIEN

Fin Tanque

NB_ELT CT

Fin NB_ELT

Exercice 2

Soit L1 une liste linéaire à valeurs VALEUR définies par l’élément structure comme suit

Nocpt Nom Prenom Solde Sens

e
Où VALEUR . Nocpte est l numéro de compte

Valeur . Sens = D si l’élément debiteur de Valeur . Solde

C s’il est créditeur de valeur Valeur .Solde

Travail demandé :

1- D’écrire le type L de la liste L1

2- Ecrire l’algo suivant : PourCred ( donne L1 : L) : reel qui calcule le pourcentage Pourcred des
éléments créditeurs de la liste L1.

Description

Type L : ENREG

ENREG = structure

Debut

Valeur = structure

Debut

Nocpte : entier

Nom : alphabétique

Prénom : alphabétique

Solde : entier

Sens : caractère

Fin

Lien : pointeur

FIN

Fonction Pourcred(donnée L1 : L) : Réel

Var CT, CTc : entier

L11 : L

Debut

L11 L1

CT 0

CTc 0

Tanque (L11 <> Null) faire

CT CT+1

Si (L11 . SENS = ‘C’) alors

 CTc CTc+1

Fin Si

Fin Tanque

Si (CT <> 0) alors

Pourcred CTc/ CT * 100

Fin Si

Fin Pourcred

Exercice 4 : fusion de 2 liste linéaire de même Type et non ordonnées

Schéma :

L1 LF L1 SVG

Fusion

L2 L2

Situation antérieure Action Situation postérieure SVG est

LF est la liste résultat (Fusion)

Remarque

Si L1 = Null alors LF L2 : C’est-à-dire que si l’une des listes est vide la fusion est L’autre

Si L2 = Null alors LF L1

Il y a deux solutions

Procedure Fusion1 (donne L1, L2 : L ;

Var L11, SVG : L

Debut

Si (L1 = NUL) alors

LF L2

Sinon

L11 L1 ; SVG L1

Tanque (L11<>NULL) faire

SVG L11

L11 L11. LIEN

Fin Tanque

SVG . LIEN L2
 Fin Si

Fin Fusion1

Procedure Fusion2 donne L1, L2 : L ; resultat LF : L

Var L11 : L

Debut

Si L1 = Null alors

LF L2

Sinon

L11 L1

LF L1

Tanque (L11 . LIEN <> NULL) faire

L11 L11 . LIEN

Fin Tanque %L11 est le dernier élément de la liste%

L11 . LIEN L2

Fin Si

FIN Fusion2

IV.) Gestion dynamique d’une liste linéaire

1.) Principe de Base
Dans la réalité gérer une liste linéaire L1 fait parallèlement à la gestion d’une liste particulièrement
appelé LIBRE.

LIBRE est une liste linéaire à éléments occupées, c’est-à-dire à valeurs inactives

Le principe de la gestion d’une liste L1 est le suivant :

a) Ajouter :
Un élément dans L1 se fait parallèlement à la suppression de cet élément de la liste LIBRE on parle de
création pour L1 (Allocation)

b) Suppression
Un élément dans L1 se fait parallèlement à l’ajout de cet élément de la liste LIBRE on parle de
suppression (Désallocation)

Ainsi la gestion dynamique engendre 2 primitives à savoir ALLOCATION et DESALLOCATION

2.) Primitives élémentaires Allocation et Désallocation

a.) Allocation
i.) Schéma

Libre p libre libre

 Allouer (p)

Situation antérieure action situation postérieur

ii.) Algorithme

Procédure Allouer (donne L1 : L ; resultat P,L1 : L)

Debut

Si (LIBRE = Null) alors

Aficher (‘pas d’espace’)

Sinon

P LIBRE

Libre LIBRE . LIEN

Fin Si

Fin Allouer

b.) Desallocation
i) Schéma
P libre p

Libre Désallouer libre

Situation initiale action Situation Finale

ii) Algorithme

Procédure Désallouer (donne LIBRE, P : L ; resultat LIBRE : L)

Debut
P . LIEN LIBRE
LIBRE P
Fin Désallouer

Remarque : Appel des primitives

a) On réduira dans la pratique les appels des primitives précédentes comme suit :
ALLOUER (P) ; DESALLOUER (P)

b) L’allocation pouvant se solder par un échec s’il n’y a pas d’espace, nous procèderons comme
suit :

Allouer (P)
Si (P <> Null) alors
‘Signifie que s’il y a un espace’
Remarque :

Dans Généralement tous les langages de programmation on suppose que l’allocation est toujours un
succès car pas de problème d’espace.

3.) Application
Il s’agit d’exercice concernant

 La création de listes linéaires

 Les mises à jour d’une liste linéaire (ajout, suppression)

a) Création d’une liste linéaire

Les valeurs peuvent provenir de plusieurs structures de données

 Saisie de valeur
 Valeurs provenant de tableaux, de fichiers, de Piles etc

Exemple :

Création d’une liste linéaire à partir de N valeurs Val saisies :

Valeur : 15, 18, -3, 40, 20

Algorithme associé

Procedure Cree_liste (donnée N :entier ; resultat L1 : L)

Var Val, i : entier ; P : L

Debut

Si (N <=0) alors

Afficher (‘Taille incorrecte’)

Sinon

L1 Null

Pour i allant de 1 à N faire

Allouer (P)

Si (P = Null) alors

Afficher (‘pas d’espace’)

Sinon

Afficher (‘donner la valeur Val’)

Saisir Val

P . Valeur Val; P .Lien Null

Si (i = 1) alors

L1 P ; SVG P

Sinon
 SVG .lien P

SVG P

Fin Si

Finsi

Fin Pour

Fin Si

Fin cree_liste

Exercice : Création d’une liste linéaire L1 à partir des éléments d’une pile S

Remarque : on utilisera un paramètre booléen PREMIER tel que

Premier = Vrai si l’élément dépilé est le premier et sera la tête de liste

Faux dans le cas contraire (élément intermédiaire)

Procedure créé_liste (donnée S : pile ; resultat L1 : L)

Var Val : entier

Premier : Booleen

P:L

Debut

L1 Null ; Premier Vrai

Tanque (PileVide(S) = faux) faire

Allouer (P)

Si (P = Null) alors

Afficher (‘pas d’espace’)

Sinon

Depiler (S, Val)

P .Valeur Val ; P . Lien Null

Si (Premier = Vrai) alors

L1 P ; SVG P ; Premier Faux

Sinon

SVG .Lien P

SVG P

Fin Si
 Fin Si

Fin Pour

FIN Cree_Liste

b) Mises à jour d’une liste linéaire

Il s’agit d’ajout et de suppression

b.1) suppression par position ou valeur

Schéma suppression du k eme élément

Remarque :

Si K = 1, c’est la tête qui change L1 L1 . Lien

Procédure sup (donnee L1 : L ; k : entier ; resultat L1 : L)

Var SVG, L11 : L

CT: entier

Debut

Si (K = 1) alors

SVG L1 ; L1 L1 . Lien ; Desallouer (SVG)

Sinon

SVG L1 ; L11 L1 ; CT 0

Tanque ((L11 <> Null) et (CT < K)) faire

CT CT + 1

Si (CT< K) alors

SVG L11 ; L11 L11 . Lien

Fin Si

Fin tanque

Si (CT < k) alors

Afficher (‘la liste a moins de K élément’)

Sinon

SVG . Lien L11 .Lien

Desallouer (L11)

Finsi

Fin Sup

Rappel : Après le parcours de la liste L1

  Soit L11 le k ème élément SVG l’éléments précédent
 Schéma

L11

SVG K

Les actions de la suppression sont les suivantes

SVG .Lien L11 . Lien

Desallouer (L11)

On parle de faire le pont

Remarque :

Si (K=1) suppression

On procède comme suit

L1 L1

SVG

SVG L1

L1 L1. Lien

Desallouer (SVG)

b.2) Ajout d’un élément de Valeur VAL à la k ème position de la liste L1

Si (K>0) Il Ya 2 cas à étudier avant cela Allouer un élément, appelons P par exemple et intégrer la
valeur

Allouer(P) ; P . Valeur VAL ; P .lien = null

1) Cas

K= 1

Positionner l’élément P en tête de la liste

L1 P

Val L1

Donc P . Lien L1

L1 P

2) Cas : Cas intermédiaire

Soit L11 l’élément de la k ème position

 SVG son prédécesseur

Val 1

L1 2

SVG L11

P .lien L1

SVG . lien P

Procedure Ajout (donne L1 : L ; Val : entier ; résultat L1 : L)

Var CT : entier

P, SVG : L

Debut

SI (K < = 0) alors

Afficher (‘Position incorrecte’)

Sinon

Allouer(P)

Si (P= null) alors

Afficher (‘Pas d’espace’)

Sinon

P . Valeur Val ; P . Lien null

Si (K = 1) alors

P . lien l1 ; l1 P

Sinon

CT O ; L11 L1

Tanque ((L11 <> null) et (CT < K)) faire

CT CT+1

SVG L11; L11 L11 . Lien

Fin Tanque

Si (CT= K) alors

P . lien L11

SVG . lien P
 Sinon

Afficher (‘La liste a moins de K éléments)

Fin Si

Fin Si

Fin Si

Fin Si

Fin Ajout

V.) Listes linéaire Particulières

Il s’agit de 2 types de listes linéaires particulières à savoir

 Ls listes linéaires circulaires

 Ls listes linéaires bidirectionnelles

1) Listes linéaires circulaire

C’est une liste linéaire dont le successeur du dernier élément est le premier élément comme
représenté dans le schéma suivant :

Remarque

Chaque élément peut jouer le rôle de tête de liste

2) Liste bidirectionnelle
Il s’agit de liste linéaire que nous notons Lb Dont chaque élément P <> Null est représenté par le
triplet suivant

PREC VALEUR SUC

Où Prec est le pointeur sur le prédécesseur de P

Suc est le pointeur sur le successeur de P

a) Définition

Une telle liste Lb est définie comme suit :

Type Lb = ENGEG

ENGEG = structure

Debut

Valeur : type_ valeur

Prec : pointeur

Suc : pointeur
 Fin

b) Primitives élémentaires
Soi P un élément d’u ne liste bidirectionnelle Lb avec P <> Null

i) Valeur
P . Valeur est la valeur associée à P
P . Prec est l’élément prédécesseur de P
P . Suc est l’élément successeur de P

Remarque : Composition

(P . Prec) . Valeur est la valeur du prédécesseur P s’il existe (P . Prec <> Null)

(P . Suc) . Valeur est la valeur du successeur P s’il existe (P . Suc <> Null)

(P . Valeur) . Suc et (P . Valeur) .Suc sont indéfinis

Remarque

 Avantage

L’avantage de cette représentation bidirectionnelle est la possibilité de se déplacer dans 2 sens et

également la facilitation des mises à jour (ajout, Suppression) car on n’a pas généralement besoin
d’élément prédécesseur d’un élément donné car obtenu par le pointeur Prec

 Inconvénient

C’est l’espace mémoire supplémentaire pour chaque élément P d’une telle liste pour stocker le
pointeur supplémentaire Prec ce n’est pas réellement très important compte tenu de la disposition
de la mémoire.
Chapitre VI : Les structures de données ARBRES
I) Préalable
Cette structure de données est utilisée pour représenter des données obéissantes entre autres à la
règle suivante

 D’un élément on peut à chaque fois atteindre plusieurs éléments : il s’agit d’une structure de
donnée dite Linéaires

1) Schéma
A

B C D

E F G H

De A on peut atteindre B, C, D

De C on peut atteindre E, F, G, H

2) Définition
Un arbre est une structure de donnée qui

 Peut-être vide
 Réduite à un élément
 Avoir plusieurs éléments dont chacun, sauf l’élément particulier appelé Racine, dépend
hiérarchiquement d’un arbre appelé père

Exemple A

B C D

E F G H I

A est la racine

B, C, D dépend hiérarchiquement

G, H, I dépend hiérarchiquement

II) Définition
a) Nœuds
Les éléments composants un arbre sont appelés les nœuds. Ils sont reliés entre eux par des éléments
appelés arêtes, on parlera de pointeurs.

b) Degré d’un nœud P

Il s’agit du nombre de nœud dépendant hiérarchiquement de P

Exemple A

B C

D E F G H I J
Degré (A) = 2 ; Degré (B) = 3 ; Degré (C) = 4 ;

Degré (D) = Degré (E) = Degré (F) = Degré (G) = Degré (H) = Degré (I) = Degré (J) = 0

c) Feuille
Un nœud est appelé feuille si son degré est égal à 0.

Dans l’exemple précédant D, E, F, G, H, I, J sont des feuilles.

d) Arbre N-aire : Arbre binaire (2-aire)

C’est un arbre dont le degré maximum de est N

Arbre Binaire : Son degré maximum est 2 l’arbre de l’exemple précédent est 4 - aire

Remarque fondamentale : Parcours

Tout arbre de N nœuds peut être parcouru de N ! manières

Exemple A Il y 3 ! Parcours (3 ! = 3 2 1 = 6) à savoir

B C

ABC, ACB, BAC, BCA, CAB, CBC

Tout arbre N-aire a un équivalent binaire construit comme dans l’exemple suivant

B C D Qui est 4 - aire à cause du nœud C

E F G H I J K

L M

N O P

Transformation en arbre Binaire

B C D degré max est 2 (Nœuds C et I) Arbre Binaire

G H I J

L M

N O P

E F

Conclusion :

Tout arbre N-Aire pouvant être représenté sous forme binaire on ne s’intéressera par la suite qu’aux
arbres binaires

III) Représentation
Préalable
Comme les autres structures de données étudiées un arbre Racine (sommet de la hiérarchie parfois
appelé Père) peut être représenté

 Par des tableaux représentation statique

 De façon chainé, représentation dynamique.

Pour les mêmes raisons signalées pour les structures de donnée précédentes, On va ici à la
représentation dynamique

1- Représentation dynamique
Arbre binaire chaque nœud P <> null est représenté par le triplet suivant :

FLG Valeur FLD

Où

Valeur : est la valeur associée à P

FLG : les pointeurs sur le fils gauche

FLD : le pointeur sur le fils droit

Exemples

L’arbre est représenté par

B C