structures de données
DESCRIPTION
Structures de Données. Algorithmique et Conception Objet. But du cours. Ce cours se propose de traiter des problèmes algorithmiques relatifs aux Structures de Données autrement appelées Conteneurs. Plan du cours. Mise en œuvre de conteneurs - Généralités - PowerPoint PPT PresentationTRANSCRIPT
Bases de la ProgrammationDpt Info, L. Lucas
Dpt Info, L. Lucas
algorithmiques relatifs aux Structures de
Données autrement appelées Conteneurs.
Dpt Info, L. Lucas
Conteneurs linéaires : TABLES & LISTES
Dpt Info, L. Lucas
définition
généricité
conclusion
Dpt Info, L. Lucas
généricité
Un conteneur, ou collection, est un objet qui réalise une structure de données qui « contient » d’autres objets.
Les conteneurs fondamentaux sont :
Dpt Info, L. Lucas
généricité
La puissance apportée par la Conception Objet ne vient pas tant de ce que celle-ci sait faire, mais plutôt de ce qu’elle est capable d’apprendre.
Autrement dit, la logique de gestion du conteneur étant indépendante du contenu, on ne s ’attachera qu’à définir le comportement du conteneur.
L ’outil privilégié qu’offre la Conception Objet est la
GENERICITE Factorisation du type contenu
Dpt Info, L. Lucas
généricité
La spécification d ’un conteneur pose deux questions essentielles, auxquelles il est nécessaire de répondre :
Le conteneur est-il homogène ou hétérogène ?
Dpt Info, L. Lucas
Homogène ou Hétérogène ?
Un conteneur qui contient des objets d ’un seul type est dit homogène.
Dpt Info, L. Lucas
Sémantique de référence ou de valeur ?
Dpt Info, L. Lucas
Sémantique de valeur
Aucun objet n’est contenu dans deux conteneurs ou plus ( il n’y a pas de partage).
Un objet est copié dans un conteneur ; si vous dites
Allouer ConteneurVal de Chose conteneur
construire (conteneur)
conteneur.ajout(t)
une nouvelle Chose est créée dans le conteneur (constructeur par copie). Les modifications futures de la Chose dans le conteneur n ’affecteront pas t et inversement.
Dpt Info, L. Lucas
Sémantique de référence
Un objet peut être « dans » plus d ’un conteneur puisque chaque conteneur contient juste une référence sur l’objet.
Mettre un objet dans un conteneur ne nécessite pas une copie de l ’objet.
Lorsque le conteneur est détruit, les objets qu’il contient ne sont pas détruits.
Dpt Info, L. Lucas
Hétérogène avec une sémantique par valeur
Ces conteneurs sont difficiles à concevoir.
Dpt Info, L. Lucas
Homogène avec une sémantique par valeur
Les patrons ou types paramètrés supportent directement ce type de conteneur.
Cf. Généricité et Cours de Y. Rémion
Dpt Info, L. Lucas
Sémantique par référence (homogène ou hétérogène)
Ce type de conteneur repose sur l ’utilisation de pointeurs qui permettent le partage par plusieurs conteneurs d’un même objet. Pour un conteneur hétérogène, les pointeurs pointent sur une classe de base commune ; cela permet d’ajouter dans le conteneur des pointeurs sur des classes dérivées.
Dpt Info, L. Lucas
généricité
Dpt Info, L. Lucas
généricité
Principe
Un algorithme classique est, la plupart du temps, dépendant des données qu’il manipule. Toute modification de ces données, même minime, peut engendrer des effets de bords indésirables.
La démarche Objet permet de dissocier l’algorithme des données sur lesquelles il opère.
Dpt Info, L. Lucas
Algorithmes génériques
Plus généralement, un outil générique est un outil dans lequel certaines informations n’ont pas été précisées et devront l’être plus tard.
Classe A
Dpt Info, L. Lucas
Concevoir « générique »
Dans beaucoup de cas, l’algorithme que l’on recherche existe déjà sur d’autres types de données. Le choix d’implémentation est alors :
soit de le transposer sur le nouveau type d ’objets,
soit de le rendre générique, puis l ’instancier sur le
nouveau type d ’objets.
Dpt Info, L. Lucas
Le premier choix repose sur une vision algorithmique conventionnelle (copier-coller). Il impose une réécriture systématique de l ’algorithme, dès lors que le type varie.
Dpt Info, L. Lucas
Dpt Info, L. Lucas
Conteneurs Linéaires
En résumé :
Une classe est générique si un ou plusieurs des types d’objets qui y sont employés ne sont pas encore définis, et devront donc être spécifiés ultérieurement lors de l’instanciation de la classe.
L’intérêt de passer par une conception générique d’un conteneur, quel que soit son type, va permettre de focaliser toute l ’attention du concepteur sur les moyens que devra mettre en œuvre ce conteneur.
Structures de Données
Dpt Info, L. Lucas
piles et files
conclusion
Dpt Info, L. Lucas
conclusion
Introduction
Les applications usuelles de l’informatique sont appelées à traiter des collections d’objets construites en assemblant quantité d ’objets homogènes.
L’exemple le plus banal de ces collections est fourni par les conteneurs linéaires dans lesquels les objets d’un même type sont déposés les uns à côté des autres.
COLLECTION
Dpt Info, L. Lucas
& sous sa forme mémoire
« objets d’un même type sont déposés les uns à côté des autres »
0
1
2
3
2
0
1
3
COLLECTION
Dpt Info, L. Lucas
conclusion
Introduction
Le choix de la structure de données sous-jacente dépend alors de l ’usage du conteneur.
Si l’objectif majeur du conteneur repose sur ses performances à l’exécution, un conteneur de type TABLE se présentera comme le meilleur compromis.
Si celui-ci s’insère dans un traitement où les éléments sont fréquemment insérés ou supprimés rien n’interdit d’opter pour un conteneur de type LISTE, ce dernier étant réhabillé de sorte que l ’utilisateur le perçoive comme une table.
Structures de Données
Dpt Info, L. Lucas
conclusion
Introduction
L’intérêt de la COO permet ici de cacher la gestion interne du conteneur. Le choix d ’implémentation de tel ou tel conteneur est un acte qui relève du concepteur de l’application.
Structures de Données
Dpt Info, L. Lucas
conclusion
La TABLE implante un conteneur dans lequel les objets d’un même type sont déposés les uns à côté des autres, dans des espaces mémoires contigus.
Accès direct aux objets de rang n est une fonctionnalité naturelle pour ce type de conteneur,
Moyen de stockage simple quand la « volatilité » des objets contenus est faible (peu insertion ou peu de suppression),
Structure statique. A savoir que l’opération de re-dimensionnement impose pour l ’utilisateur un choix volontariste et pour le concepteur, une opération explicite.
Structures de Données
Dpt Info, L. Lucas
Interface utilisateur
Dépend de :
Variables Globales / Champs Publics :
Fonctions et opérateur :
construire(acreer ex Tab de X, n nouv N, z nouv Z, x nouv X)
indéxée par [z,z+n[
construire(acreer ex Tab de X, n nouv N, x nouv X)
indéxée par [0,n[
indéxée par [0,1[
construire(acreer ex Tab de X, t cons Tab de X)
op = (acreer ex Tab de X, t cons Tab de X) res ex Tab de X
constructeur par copie et réaffecteur
(même espace d’indexation allocation
même taille recopie des éléments)
détruire(adet ex Tab de X) destructeur (libère espace alloué)
p 1/2
Dpt Info, L. Lucas
Autres fonctions :
IndexPremierElem (t cons Tab de X) res nouv Z Index de début
IndexDernierElem (t cons Tab de X) res nouv Z Index de fin
(dernier utilisé : z+n-1)
NombreElem (t cons Tab de X) res nouv N n
IndexValide (t cons Tab de X) res nouv B
Déroutable par ErrIndexInvalide
z dans espace indexation de t ?
op [ ] (t ex Tab de X, Z nouv z) res ex X
Déroutable par ErrIndexInvalide
écrire Indisponible, utiliser la fonction écrire du type X
saisir Indisponible, utiliser la fonction saisir du type X
p 2/2
Dpt Info, L. Lucas
n nouv N,
z nouv Z,
x nouv X)
Taille de la table
Indice du premier élément
Dpt Info, L. Lucas
construire (tb, 8, 2, N éphémère (8))
2
3
4
5
6
7
8
9
construire (tb, 8, N éphémère (3))
0
1
2
3
4
5
6
7
Dpt Info, L. Lucas
0
construire (tout, tin)
Dpt Info, L. Lucas
réserver un espace mémoire de nb X,
maintenir l’adresse retournée,
initialiser l’indice de la première occurrence.
Le mécanisme mis en œuvre est comparable à la création d’objets durables non nommés (Cf. Cours Algo) pour lequel on va :
réserver nb espace(s) mémoires contigus typés de type X,
mémoriser l ’adresse du premier élément.
Structures de Données
Dpt Info, L. Lucas
conclusion
Il est utile de savoir créer des objets non nommés durables (nb et valeurs inconnus à la compilation)
Pour ce faire les méta-fonctions suivantes seront supposées exister pour tout type T et toute liste de paramètres licite pour construire un T :
T durable ( paramètres ) res nouv Adr de T
début Allouer T t
Structures de Données
Dpt Info, L. Lucas
construire (tb, 8, 2, N éphémère (8))
2
3
4
5
6
7
8
9
réserver sur le tas un espace mémoire de nb X,
maintenir l’adresse retournée,
initialiser l’indice de la première occurrence.
& Res nouv Adr de X
Structures de Données
Dpt Info, L. Lucas
Recyclage des erreurs à la construction
La réservation de Xs durables est ici explicitement définie par le concepteur de la classe Tab. Cette étape est susceptible de provoquer des erreurs qu’il est obligatoire de prendre en compte.
Mise en place d’un mécanisme d’exception adapté
ErrAllocationMémoire
Structures de Données
Dpt Info, L. Lucas
conclusion
construire (acreer ex Tab de X, n nouv N, x ex X)
Déroutable par ErrAllocationMémoire
Si « réservation des n Xs est effectuée sans anomalie » Alors
Deb
Recyclage des erreurs à la construction
Structures de Données
Dpt Info, L. Lucas
Le destructeur
Cette fonctionnalité doit veiller à restituer l’ensemble de la mémoire consommée par la table adet.
détruire (adet ex Tab de X)
Son objectif consiste à :
détruire les instances de adet,
rendre l’espace mémoire affecté à ces instances, ce qui revient à oublier l’adresse retournée lors de la construction de adet
Structures de Données
Dpt Info, L. Lucas
Le réaffecteur
op = (dst ex Tab de X, src ex Tab de X)
res ex Tab de X
Déroutable par ErrAllocationMémoire
allouer dst (cf. Constructeur par copie)
copier le contenu de src dans dst (cf. Constructeur par copie).
Structures de Données
Dpt Info, L. Lucas
res ex X
Déroutable par ErrIndexInvalide
construire (tb, 8, 2, N éphémère (8))
2
3
4
5
6
7
8
9
Dpt Info, L. Lucas
Dpt Info, L. Lucas
Son principe algorithmique repose sur :
identification de l ’adresse Adr1 de X d ’implantation mémoire de la table,
décalage par rapport à cette adresse de
Adr2 de X = Adr1 de X + index * taille_de(X)
déréférencement d ’un X en Adr2 de X,
Structures de Données
Dpt Info, L. Lucas
Adr de T
Rôle : Pointeur de T, objet mémorisant l ’adresse d ’un objet de type T, on dit aussi « pointant sur » un objet de type T.
Interface utilisateur
Dépend de :
Fonctions et opérateurs :
construire (ex Adr de T, ex Adr de T) constructeur par copie
détruire (ex Adr de T) destructeur
op = (ex Adr de T,
nouv Adr de T) ex Adr de T réaffecteur
construire (ex Adr de T) constructeur par défaut
adresse illicite (0)
Adresse (t ex T) nouv Adr de T pointage de t,adresse de t
Contenu (a nouv Adr de T) ex T objet « pointé » par a,
objet de type T à l‘adresse a
IUT Léonard de Vinci, Reims
Dpt Info, L. Lucas
8
8
8
8
8
6
8
8
construire (tb, 8, 2, N éphémère (8))
2
3
4
5
6
7
8
9
8
Dpt Info, L. Lucas
construire (tb, 8, 2, N éphémère (0))
écrire (IndexPremierElem(tb), OUT)
écrire (IndexDernierElem(tb), OUT)
écrire (NombreElem(tb), OUT)
Dpt Info, L. Lucas
Problème du parcours d’une TABLE
L’idée la plus simple consiste à parcourir la table dans l’ordre croissant de ses indices. On obtient ainsi le schéma d’énumération séquentiel “de gauche à droite” des éléments de la table.
Allouer Z i
construire (tb, 8, 2, N éphémère (8))
construire (i, IndexPremierElem (tb))
deb
Dpt Info, L. Lucas
Algorithmes d’accès à un élément d’une TABLE
Soit une table T[imin … imax]. L’accès par position est défini par la fonction d’indexation T[i]. L’accès associatif est le plus courant. Soit elem une variable contenant une valeur de même type que celles contenues dans T, on veut déterminer s’il existe un indice i [imin … imax] tel que T[i] = elem.
Cet accès peut être réalisé de plusieurs manières suivant que l’on suppose T trié ou non.
Structures de Données
Dpt Info, L. Lucas
Raisonnement par récurrence :
Supposons traités les i-1 ( [z < i < z + n[ ) premiers éléments de la table T, et que elem T[z … i-1].
i = z + n elem T[z … z + n[
l’algorithme est terminé, elem T.
i < z + n
T[i] = elem elem [z … z + n[, l’algorithme est terminé, elem T
T[i] elem elem T[z … i], l ’exécution de l ’instruction i = i + 1 permet de déclencher l’assertion elem T[z … i-1].
Structures de Données
Dpt Info, L. Lucas
Initialisation
l’action i = z permet de déclencher l ’assertion précédente
Progression
INVARIANT
vrai vrai vrai
vrai faux faux
Dpt Info, L. Lucas
Phase de progression
i = z + n
Dpt Info, L. Lucas
5
3
0
7
8
1
6
4
construire (tb, 8, 2, N éphémère (0))
…
2
3
4
5
6
7
8
9
2 faux faux
3 faux faux
4 faux faux
5 faux faux
6 faux faux
7 faux faux
8 faux faux
9 faux faux
Dpt Info, L. Lucas
5
3
0
7
8
1
2
4
construire (tb, 8, 2, N éphémère (0))
…
2
3
4
5
6
7
8
9
2 faux faux
3 faux faux
4 faux faux
5 faux faux
6 vrai vrai
Dpt Info, L. Lucas
Version récursive / parcours de gauche à droite
RechercheR (tb ex Tab de T, elem nouv T) res nouv B
Début
Fin
recherche (tb ex Tab de T, z nouv Z, elem nouv T) res nouv B
Début
sinon si tb[z] == elem
alors construire (res, B éphémère (Vrai))
sinon construire (res, recherche (tb, z + 1, elem))
Fin
Dpt Info, L. Lucas
Version récursive / parcours de droite à gauche
RechercheR (tb ex Tab de T, elem nouv T) res nouv B
Début
Fin
recherche (tb ex Tab de T, z nouv Z, elem nouv T) res nouv B
Début
sinon si tb[z] == elem
alors construire (res, B éphémère (Vrai))
sinon construire (res, recherche (tb, z - 1, elem))
Fin
Dpt Info, L. Lucas
Recherche séquentielle / TABLE triée
Si tous les éléments consécutifs d’une table vérifient la relation d’ordre
T[i-1] T[i]
on dit que la table est triée par ordre croissant (ou ordonnée). On admettra qu’une table vide ou qu’une table ne contenant qu’un seul élément sont aussi triées.
Structures de Données
Dpt Info, L. Lucas
une table T (NombreElem(T) = 1) est ordonnée
une table T[ … ] avec < est ordonnée si
i [+1 … ], T[i-1] T[i]
une table T vide (NombreElem(T) = 0) est ordonnée
une table T (NombreElem(T) = 1) est ordonnée
T[ … i-1] est ordonnée, T[i-1] T[i]
T[ … i] est ordonnée pour i [+1 … ]
Structures de Données
Dpt Info, L. Lucas
T[ … i-1] < elem T[i … ]
soit une assertion
Dpt Info, L. Lucas
l’action i = z permet de déclencher l ’assertion précédente
Progression
INVARIANT
vrai vrai vrai
vrai faux faux
Dpt Info, L. Lucas
construire (tb, 8, 2, N éphémère (0))
…
2
3
4
5
6
7
8
9
2 faux faux
3 faux faux
4 faux faux
5 faux faux
6 vrai vrai
Dpt Info, L. Lucas
construire (tb, 8, 2, N éphémère (0))
…
2
3
4
5
6
7
8
9
2 faux faux
3 faux faux
4 faux faux
5 faux faux
Dpt Info, L. Lucas
Recherche dichotomique / TABLE triée
On partitionne la table T en trois sous-tables T[imin … m-1], T[m … m], T[m+1 … imax] ordonnées. Cette partition vérifie la relation :
T[imin … m-1] T[m … m] T[m+1 … imax]
En comparant elem à T[m], on peut décider à quel sous-table appartient elem si elem T[m] soit :
T[imin … m-1] si elem < T[m]
T[m+1 … imax] si elem > T[m]
Structures de Données
Dpt Info, L. Lucas
On est donc ramené au même problème que précédemment :
rechercher elem dans une table (T[imin … m-1] ou T[m+1 … imax]).
Par contre si elem = T[m] l ’algorithme est terminé
Structures de Données
Dpt Info, L. Lucas
m
inf
sup
elem T
algorithme terminé
inf <= sup
Dpt Info, L. Lucas
Raisonnement par récurrence :
Supposons T[z … inf-1] elem T[sup+1 ... z+n[, non trouvé.
inf = sup + 1 elem T, résultat = Faux
inf sup
T[m] > elem sup = m - 1
T[m] < elem inf = m + 1
Itération : tantque inf sup Et non trouve
Initialisation : inf = IPE(T), max = IDE(T)
trouve = Faux
Dpt Info, L. Lucas
construire (tb, 8, 2, N éphémère (0))
…
2
3
4
5
6
7
8
9
init 2 9 V F
1 2 4 5 V F
2 3 V V
Dpt Info, L. Lucas
construire (tb, 8, 2, N éphémère (0))
…
2
3
4
5
6
7
8
9
init 2 9 V F
1 6 9 5 V F
2 8 9 7 V F
3 9 9 8 V F
4 10 9 9 F F
Structures de Données
Dpt Info, L. Lucas
Algorithmes de tris d’une TABLE
Soit une table T[imin … imax] à valeurs dans un ensemble E de valeurs muni d’une relation d’ordre notée <. Trier la table T consiste à construire une table T’[imin … imax] tel que :
T’ soit triée,
Structures de Données
Dpt Info, L. Lucas
Dpt Info, L. Lucas
Tri par remplacement
On veut construire une table triée T’[imin … imax] à partir de T[imin … imax] tel que
T’[i-1] T’[i], i [imin+1 … imax]
Pour i= imin+1, on a donc :
T’[imin] T’[imin+1 … imax]
T’[imin] = minimum(T[imin … imax] )
Structures de Données
Dpt Info, L. Lucas
ajout du minimum dans T’
substitution du minimum de T par la valeur majorante de T
valeur majorante = maximum(T)
Structures de Données
Dpt Info, L. Lucas
Tri par remplacement
Raisonnement par récurrence :
Supposons T’[z … i-1] triée, T’[z … i-1] T[z ... z+n[, et max = maximum(T[z ... z+n[).
i = z + n - 1 T’ est triée, T ’[z … z+n-2] T[z ... z+n[
T’[z + n - 1] = max
i < z + n - 1
Soit j tel que T[j] = minimum(T[z ... z+n])
T’[i] = T[j], T[j] = max, i = i + 1.
Itération : tantque i < IndexDernierElement (T)
Initialisation : i = 1, max = maximum(T)
Structures de Données
Dpt Info, L. Lucas
Tri par remplacement
Exemple : trier dans l ’ordre alphabétique les lettres du mot « TABLEAUX ». Le maximum est égal à ‘ X ’.
j [1,8]
Dpt Info, L. Lucas
Début
Allouer N i, j
Structures de Données
Dpt Info, L. Lucas
Supposons max T [z … i-1], max T[z ... i-1].
i = z + n max T[z ... z+n[, max T[z ... Z+n[
résultat = max
T[i] max i = i + 1
Itération : tantque i < IndexDernierElement (T)
Initialisation : max = T[IndexPremierElement(T)]
Dpt Info, L. Lucas
Début
i = i + 1
Structures de Données
Dpt Info, L. Lucas
Supposons j [z … i-1], T[j] T[z ... i-1].
i = z + n j [z … z+n[, T[j] T[z ... z+n[
résultat = j
T[j] T[i] i = i + 1
Itération : tantque i IndexDernierElement (T)
Initialisation : i = IndexPremierElement(T), i = j + 1
Structures de Données
Dpt Info, L. Lucas
Début
i = i + 1
Structures de Données
Dpt Info, L. Lucas
Supposons traités i-1 (imin i imax) éléments de T.
On peut donc considérer la table T comme la concaténation de 2 sous-tables : la sous-table T[imin … i-1] dont les éléments sont triés, et la sous-table T[i … imax] dont les éléments n’ont pas encore été traités. D ’autre part tous les éléments de la sous-table T[imin … i-1] sont inférieurs ou égaux à tous les éléments de la sous-table T[i … imax].
imin
imax
i
i-1
triée
Dpt Info, L. Lucas
j [1,7]
Exemple : trier dans l ’ordre alphabétique les lettres du mot « BATEAUX ».
T
Dpt Info, L. Lucas
Raisonnement par récurrence :
Supposons T[z … i-1] triée, T[i … z+n[ non traitée
et T[z … i-1] T[i … z+n[.
i = z + n - 1 T[i] non traité, T[z … i-1] T[z+n-1]
T[z … i-1] est triée, T[z … z+n[ est aussi triée
i < z + n - 1
Soit j tel que T[j] = minimum de T[i … z+n[, j [i … z+n[
j = i i = i + 1
j i permuter T[j] avec T[i], i = i + 1
Itération : tantque i < IndexDernierElement(T)
Dpt Info, L. Lucas
Supposons traités i-1 (imin i imax) éléments de T.
On retrouve la situation que nous avons déjà vue dans la méthode précédente. Pour augmenter la sous-table triée d’un élément, il faut chercher le plus petit élément contenu dans la sous-table non traitée et le placer en position i. Nous allons cette fois, au lieu de la recherche du minimum suivie d’une permutation, utiliser la méthode dite des bulles.
imin
imax
i
i-1
triée
Dpt Info, L. Lucas
conclusion
On parcourt la sous-table T[i … imax] de droite à gauche et, chaque fois qu’il y a deux éléments consécutifs qui ne sont pas dans l’ordre, on les permute. Cette opération permet d’obtenir en fin de parcours le plus petit élément de T [i … imax] placé en position i.
Structures de Données
Dpt Info, L. Lucas
j [1,7]
Exemple : trier dans l ’ordre alphabétique les lettres du mot « BATEAUX ».
T
A
A
B
E
T
U
fini
Dpt Info, L. Lucas
Raisonnement par récurrence :
Supposons T[z … i-1] triée, T[i … z+n[ non traitée
et T[z … i-1] T[i … z+n[.
i = z + n - 1 T[z … i-1] est triée, T[z … i-1] T[z+n-1]
T[z … z+n[ est aussi triée
i < z + n - 1
Permutations (« bulles ») de telle sorte que le minimum de T[i … z+n[ soit placé en T[i], i = i + 1
Itération : tantque i < IndexDernierElement(T)
Dpt Info, L. Lucas
Tri à bulles / optimisation de l ’algorithme
A
A
B
fini
Dpt Info, L. Lucas
Supposons traités i-1 (imin i imax) éléments de T.
Il suffit d’insérer l’élément T[i] dans la sous-table déjà trié pour augmenter celle-ci d’un élément. Il s ’agit donc d’ajouter à la sous-table triée un nouvel élément elem, qui est dans le même temps supprimé de la sous-table non traitée.
imin
imax
i
i-1
triée
Dpt Info, L. Lucas
j [1,7]
Exemple : trier dans l ’ordre alphabétique les lettres du mot « BATEAUX ».
T
AB/TEAUX
ABT/EAUX
ABET/AUX
AABET/UX
AABETU/X
AABETUX/
fini
Dpt Info, L. Lucas
Raisonnement par récurrence :
Supposons T[z … i] triée, T[i+1 … z+n[ non traitée.
i = z + n - 1 T[z … z+n[ est triée
i < z + n - 1 insertion (T[z … i], T[i+1])
Itération : tantque i < IndexDernierElement(T)
Dpt Info, L. Lucas
Ttrié[i] elem p = i +1
Ttrié[i] > elem i = i - 1
Itération : tantque Ttrie[i] > elem
Initialisation : si Ttrié[IPE(T)] > elem alors p = 1
sinon i = n
Tri par insertion
Dpt Info, L. Lucas
conclusion
Il s’agit d’un algorithme qui se présente sous plusieurs versions ayant toutes, dans le cas général, de meilleures performances que les algorithmes précédents. Il est basé sur le principe de « diviser pour régner » que nous avons déjà utilisé dans l’algorithme de recherche dichotomique.
Structures de Données
Dpt Info, L. Lucas
conclusion
Supposons que nous ayons à trier une table T[inf … sup] avec inf < sup. Nous allons segmenter cette table en trois sous-tables telles que :
tous les éléments se trouvant à gauche de place (place [inf … sup] soient inférieurs ou égaux à T[place] et que ceux se trouvant à doite de place soient supérieurs à T[place].
place
inf
sup
Dpt Info, L. Lucas
et on constate
que T[place] est correctement rangé,
qu’il ne reste plus qu’à trier les deux sous-tables.
T[inf … place-1] et T[place+1 … sup]
Structures de Données
Dpt Info, L. Lucas
conclusion
TriSegmentation(T ex Tab de X, inf nouv Z, sup nouv Z)
Début
fin
Fin, Eliminer place, inf, sup Oublier T
Pour trier T, il suffit d’appeler la fonction TriSegmentation de la façon suivante : TriSegmentation (T, IPE(T), IDE(T))
Structures de Données
Dpt Info, L. Lucas
Supposons T[inf … i-1] pivot < T[j+1 … sup]
i = j + 1 permutation de T[inf] avec T[j], place = j
i j
T[i] pivot i = i + 1
T[i] > pivot permuter T[i] avec T[j], j = j - 1
Itération : tantque i j
Structures de Données
Dpt Info, L. Lucas
& sous sa forme mémoire
« objets d’un même type sont déposés les uns à côté des autres »
0
1
2
3
2
0
1
3
COLLECTION
Dpt Info, L. Lucas
conclusion
La LISTE implante un conteneur dans lequel les objets d’un même type sont déposés les uns à côté des autres, dans des espaces mémoires non contigus.
Structure dynamique. A savoir que l’opération de re-dimensionnement n’impose pas pour l’utilisateur un choix particulier,
Moyen de stockage simple quand la « volatilité » des objets contenus est importante (insertion / suppression nombreuses),
Accès direct aux objets de rang n impose un balayage systématique du conteneur.
Structures de Données
Dpt Info, L. Lucas
conclusion
La LISTE chaînée se présente comme l ’autre alternative à l’utilisation de TABLE. Elle fournit sensiblement le même service, en rassemblant une suite d’éléments, mais n’oblige pas ces éléments à rester concaténés physiquement en mémoire. Elle permet de faire disparaître un élément de milieu de liste aussi facilement qu’un élément en début ou fin de liste.
STRUCTURE HAUTEMENT DYNAMIQUE
Structures de Données
Dpt Info, L. Lucas
conclusion
La gestion dynamique (de la mémoire) doit donc nous permettre de faire apparaître, puis disparaître, comme bon nous semble, des objets anonymes.
En reliant ces objets les uns aux autres, nous pouvons développer des structures de données (conteneurs) non contigus
Structures de Données
Dpt Info, L. Lucas
conclusion
Définition
Une liste chaînée est une structure composée d’éléments chaînés les uns aux autres. Le chaînage entre deux de ces éléments s’obtient en plaçant dans l’un des deux élément (ou dans les deux), un lien faisant référence à l’autre.
Pour avoir accès à l’ensemble des éléments de la liste, il suffit de posséder l’adresse du premier dans le cas d’un simple chaînage.
5
23
9
16
7
18
Tête
Dpt Info, L. Lucas
Modes de chaînage
Le chaînage d’une liste peut se présentes de différentes manières. Les plus communes sont les suivantes :
5
23
9
16
7
18
Tête
5
23
9
16
7
18
Tête
Queue
5
23
9
16
7
18
Tête
Queue
Dpt Info, L. Lucas
Représentation d’un élément
On définit un élément (cellule / nœud) dans le cas d’une liste simplement chaînée, comme un couple composé d’une information de type X et un pointeur (élément de X) contenant l’adresse de l’élément suivant.
X
Adresse
Dpt Info, L. Lucas
Gestion dynamique de la mémoire
Si on souhaite conserver certains objets (ex. Cellule de X) de façon DURABLE, cela suppose la capacité d’obtenir du système des emplacements de mémoire vierges et bien sûr la capacité de les lui rendre, dès que leur besoin ne se fera plus sentir.
Dpt Info, L. Lucas
Gestion dynamique de la mémoire
Naturellement, pour être en mesure de gérer ces emplacements mémoire, il faut disposer d’objets capables de mémoriser des adresses mémoires. Ces objets sont les pointeurs.
Un objet de type pointeur peut contenir une adresse quelconque et donc « pointer » sur n’importe quel objet. Il s’agit donc bien d’un type générique.
Adresse de X ou Pointeur de X
Structures de Données
Dpt Info, L. Lucas
conclusion
Il est utile de savoir créer des objets non nommés durables (nb et valeurs inconnus à la compilation)
Pour ce faire les méta-fonctions suivantes seront supposées exister pour tout type T et toute liste de paramètres licite pour construire un T :
T durable ( paramètres ) res nouv Adr de T
début Allouer T t
Structures de Données
Dpt Info, L. Lucas
Adr de T
Rôle : Pointeur de T, objet mémorisant l ’adresse d ’un objet de type T, on dit aussi « pointant sur » un objet de type T.
Interface utilisateur
Dépend de :
Structures de Données
Fonctions et opérateurs :
construire (ex Adr de T, ex Adr de T) constructeur par copie
détruire (ex Adr de T) destructeur
op = (ex Adr de T,
nouv Adr de T) ex Adr de T réaffecteur
construire (ex Adr de T) constructeur par défaut
adresse illicite (0)
Adresse (t ex T) nouv Adr de T pointage de t,adresse de t
Contenu (a nouv Adr de T) ex T objet « pointé » par a,
objet de type T à l‘adresse a
IUT Léonard de Vinci, Reims
Dpt Info, L. Lucas
Dpt Info, L. Lucas
Dpt Info, L. Lucas
Interface utilisateur
Dépend de :
Variables Globales / Champs Publics :
construire(acreer ex LstS de X, l ex LstS de X)
op = (dst ex LstS de X, src ex LstS de X) res ex LstS de X
constructeur par copie et réaffecteur
(recopie des éléments)
Déroutable par ErrAllocationMémoire
détruire (adet ex LstS de X) destructeur (libère espace alloué)
p 1/2
Première approche
vision propriétaire
Dpt Info, L. Lucas
Interface utilisateur
Dépend de :
Variables Globales / Champs Publics :
construire(acreer ex LstS de X, l ex LstS de X)
op = (dst ex LstS de X, src ex LstS de X) res ex LstS de X
constructeur par copie et réaffecteur
(recopie des éléments)
Déroutable par ErrAllocationMémoire
détruire (adet ex LstS de X) destructeur (libère espace alloué)
p 1/2
Première approche
vision propriétaire
Dpt Info, L. Lucas
Autres fonctions :
Vide (l ex LstS de X) res nouv B Liste l vide
Premier (l ex LstS de X) res ex X Premier élément de l
Déroutable par ErrListeVide MAJ position courante
Courant (l ex LstS de X) res ex X Retourne élément
Déroutable par ErrListeVide courant
Suivant (l ex LstS de X) res ex X Elément suivant la
Déroutable par ErrFinListe position courante
MAJ position courante
Ajout (l ex LstS de X, x nouv X) Ajout d ’un élément
Déroutable par ErrAllocationMémoire x par rapport à la
position courante
Déroutable par ErrListeVide l’élément courant
écrire Indisponible, utiliser la fonction écrire du type X
saisir Indisponible, utiliser la fonction saisir du type X
p 2/2
Dpt Info, L. Lucas
P_GD (l ex LstS de X) Déroutable par ErrFinListe, ErrListeVide
Début
Début
Fin Oublier l Eliminer tmp
L ’algorithme s’arrête lorsqu’il n’y a plus d’éléments à traiter
dérouter par ErrFinListe /ErrListeVide
Dpt Info, L. Lucas
parcoursgd (liste 1)
traiter (liste 1)
parcoursgd (liste 2)
traiter (liste 2)
parcoursgd (liste 3)
traiter (liste 3)
parcoursgd (liste 4)
traiter (liste 4)
traiter (liste i)
Dpt Info, L. Lucas
P_DG (l ex LstS de X) Déroutable par ErrFinListe, ErrListeVide
Début
Parcoursdg(l ex LstS de X) Déroutable par ErrFinListe
Début
Structures de Données
Dpt Info, L. Lucas
parcoursdg (liste 1)
parcoursdg (liste 2)
parcoursdg (liste 3)
parcoursdg (liste 4)
parcoursdg (liste i+1)
Dpt Info, L. Lucas
Parcoursgd(l ex LstS de X) Déroutable par ErrFinListe,
ErrListeVide
Début
début
Structures de Données
Dpt Info, L. Lucas
Longueur d’une liste / Schéma itératif
Supposons traités les n premiers éléments de la liste. On a la situation suivante :
n = long(L) où long désigne le nombre d ’éléments de la liste L.
5
23
9
16
7
18
Tête
L
Dpt Info, L. Lucas
L <>
Structures de Données
Dpt Info, L. Lucas
Structures de Données
Dpt Info, L. Lucas
=(1+(1+(1+(1+(1+long(L6))))))
=(1+(1+(1+(1+(1+(1+long(NULL)))))))
= 6
L1
L2
L3
L4
L5
L6
Dpt Info, L. Lucas
12
Elem
5
23
9
16
7
18
Tête
12
Elem
Dpt Info, L. Lucas
Démarche algorithmique
création d’une cellule de X durable d’adresse Elem
chaînage de la nouvelle cellule avec la liste (l’élément suivant de Elem Tête)
réaffectation de Tête (Tête = Elem)
Structures de Données
Dpt Info, L. Lucas
12
Elem
5
23
9
16
7
18
Tête
12
Elem
Dpt Info, L. Lucas
Démarche algorithmique
création d’une cellule de X durable d’adresse Elem
MAJ position courante (l’élément courante = adresse de la dernière cellule)
chaînage de la nouvelle cellule avec la liste (l’élément suivant du courant Elem)
Structures de Données
Dpt Info, L. Lucas
12
Elem
5
23
9
16
7
18
Tête
12
Elem
C
C
PC
Dpt Info, L. Lucas
Démarche algorithmique
création d’une cellule de X durable d’adresse Elem
chaînage de la liste avec nouvelle cellule (l’élément suivant du précédent du courant Elem)
chaînage de la nouvelle cellule avec la liste (l’élément suivant de Elem C)
Structures de Données
Dpt Info, L. Lucas
12
Elem
5
23
9
16
7
18
Tête
12
Elem
C
C
Dpt Info, L. Lucas
Démarche algorithmique
création d’une cellule de X durable d’adresse Elem
chaînage de la liste avec nouvelle cellule (l’élément suivant de C Elem)
chaînage de la nouvelle cellule avec la liste (l’élément suivant de Elem suivant de C)
Structures de Données
Dpt Info, L. Lucas
5
23
9
16
7
18
Tête
Elem
Dpt Info, L. Lucas
Démarche algorithmique
réaffectation de Tête (Tête = l’élément suivant de Tête)
destruction de la cellule durable d’adresse Elem
Structures de Données
Dpt Info, L. Lucas
5
23
9
16
7
18
Tête
C
PC
Elem
Dpt Info, L. Lucas
Démarche algorithmique
MAJ position courante et mémorisation de cette position (Elem = C = adresse de la dernière cellule)
chaînage (l’élément suivant de PC NULL)
destruction de la cellule durable d’adresse Elem
réaffectation du courant (C = PC)
Structures de Données
Dpt Info, L. Lucas
5
23
9
16
7
18
Tête
C
Elem
PC
Dpt Info, L. Lucas
Démarche algorithmique
chaînage (l’élément suivant de PC suivant de C)
destruction de la cellule durable d’adresse Elem
réaffectation du courant (C = PC)
Structures de Données
Dpt Info, L. Lucas
Raisonnement par récurrence :
L = <> résultat = n
Courant(L) val, Suivant (L)
Dpt Info, L. Lucas
Raisonnement par récurrence :
L = <>
Courant(L) val, résultat = nbocc(Suivant(L), val)
Structures de Données
Dpt Info, L. Lucas
Accès dans une liste
De façon identique à ce que nous avons décrit dans le cas de la gestion d’une table, on distingue pour les listes 2 sortes d ’accès :
l’accès par position
Dpt Info, L. Lucas
Accès par position / Schéma itératif
L ’algorithme s’arrête si il n’y a plus d’éléments à traiter
dérouter par ErrFinListe/ErrListeVide ou si i = n
Op [] (l ex LstS de X, n nouv N) res ex X
Déroutable par ErrFinListe
Structures de Données
Dpt Info, L. Lucas
Accès par position / Schéma récursif
Op [] (l ex LstS de X, n nouv N) res ex X
Déroutable par ErrFinListe
Fin Oublier l Eliminer n
elementk (l ex LstS de X, n nouv N) res ex X
Déroutable par ErrFinListe
sinon construire (res, elementk(Suivant(l),n-1))
Fin Oublier l Eliminer n
L ’algorithme s’arrête si,il n’y a plus d’éléments à traiter
dérouter par ErrFinListe/ErrListeVide ou si n = 0
Structures de Données
Dpt Info, L. Lucas
Accès associatif / Schéma itératif
Recherche (l ex LstS de X, x nouv X) res nouv B
Déroutable par ErrFinListe
construire (res, B éphémère (Vrai))
Fin Oublier l Eliminer n, i
L ’algorithme s’arrête si il n’y a plus d’éléments à traiter
dérouter par ErrFinListe/ErrListeVide ou si x l
Accès associatif = Recherche
Structures de Données
Dpt Info, L. Lucas
Interface utilisateur
Dépend de :
Variables Globales / Champs Publics :
construire(acreer ex LstD de X, l ex LstD de X)
op = (dst ex LstD de X, src ex LstD de X) res ex LstD de X
constructeur par copie et réaffecteur
(recopie des éléments)
Déroutable par ErrAllocationMémoire
détruire (adet ex LstD de X) destructeur (libère espace alloué)
p 1/2
Première approche
vision propriétaire
Dpt Info, L. Lucas
Autres fonctions :
Vide (l ex LstD de X) res nouv B Liste l vide
Premier (l ex LstD de X) res ex X Premier élément de l
Déroutable par ErrListeVide MAJ position courante
Courant (l ex LstD de X) res ex X Retourne élément
Déroutable par ErrListeVide courant
Suivant (l ex LstD de X) res ex X Elément suivant la
Déroutable par ErrFinListe position courante
MAJ position courante
Précédent (l ex LstD de X) res ex X Elément suivant la
Déroutable par ErrFinListe position courante
MAJ position courante
Ajout (l ex LstD de X, x nouv X) Ajout d ’un élément
Déroutable par ErrAllocationMémoire x par rapport à la
position courante
Déroutable par ErrListeVide l’élément courant
écrire Indisponible, utiliser la fonction écrire du type X
saisir Indisponible, utiliser la fonction saisir du type X
p 2/2
Dpt Info, L. Lucas
12
Elem
5
23
9
16
7
18
Tête
Queue
12
Tête
5
23
9
16
7
18
Queue
Dpt Info, L. Lucas
12
Elem
5
23
9
16
7
18
Tête
Queue
12
5
23
9
16
7
18
Tête
Queue
Dpt Info, L. Lucas
12
Elem
5
23
9
16
7
18
Tête
Queue
C
12
5
23
9
16
7
18
Tête
Queue
Dpt Info, L. Lucas
12
Elem
5
23
9
16
7
18
Tête
Queue
C
12
5
23
9
16
7
18
Tête
Queue
Dpt Info, L. Lucas
5
23
9
16
7
18
Tête
Queue
23
9
16
7
18
Tête
Queue
5
Elem
Dpt Info, L. Lucas
5
23
9
16
7
18
Tête
Queue
5
23
9
16
7
Tête
Queue
18
Elem
Dpt Info, L. Lucas
5
23
9
16
7
18
Tête
Queue
C
5
23
9
16
7
18
Tête
Queue
Elem
C
Dpt Info, L. Lucas
Dpt Info, L. Lucas
Dpt Info, L. Lucas
conclusion
Le principe général consiste à dissocier la gestion de la structure de données des éléments nécessaires à son parcours. Les avantages majeurs apportés par ce type d’approches reposent sur :
des parcours multiples d’une même entité,
un développement modulaire du concept sous-jacent.
Structures de Données
Dpt Info, L. Lucas
Interface utilisateur
Dépend de :
Variables Globales / Champs Publics :
construire(acreer ex LstS de X) création d’une liste vide
construire(acreer ex LstS de X, l ex LstS de X)
op = (dst ex LstS de X, src ex LstS de X) res ex LstS de X
constructeur par copie et réaffecteur
(recopie des éléments)
Déroutable par ErrAllocationMémoire
détruire (adet ex LstS de X) destruction des éléments (libère espace alloué)
p 1/2
Seconde approche
vision partagée
Dpt Info, L. Lucas
Autres fonctions :
Vide (l ex LstS de X) res nouv B Liste l vide
Vider (l ex LstS de X) Remise à zéro de l
Ajout (l ex LstS de X, x nouv X) Ajout d’un élément x
Déroutable par ErrAllocationMémoire en tête de l
Ajout (ld ex LstS de X, ls ex LstS de X) Ajout d’une liste ls
Déroutable par ErrAllocationMémoire en tête de ld
écrire Indisponible, utiliser la fonction écrire du type X
saisir Indisponible, utiliser la fonction saisir du type X
p 2/2
Dpt Info, L. Lucas
Interface utilisateur
Dépend de :
Variables Globales / Champs Publics :
construire(acreer ex LstD de X) création d’une liste vide
construire(acreer ex LstD de X, l ex LstD de X)
op = (dst ex LstD de X, src ex LstD de X) res ex LstD de X
constructeur par copie et réaffecteur
(recopie des éléments)
Déroutable par ErrAllocationMémoire
détruire (adet ex LstD de X) destruction des éléments (libère espace alloué)
p 1/2
Seconde approche
vision partagée
Dpt Info, L. Lucas
Autres fonctions :
Vide (l ex LstD de X) res nouv B Liste l vide
Vider (l ex LstD de X) Remise à zéro de l
Ajout (l ex LstD de X, x nouv X) Ajout d’un élément x
Déroutable par ErrAllocationMémoire en tête de l
Ajout (ld ex LstD de X, ls ex LstD de X) Ajout d’une liste ls
Déroutable par ErrAllocationMémoire en tête de ld
écrire Indisponible, utiliser la fonction écrire du type X
saisir Indisponible, utiliser la fonction saisir du type X
p 2/2
Dpt Info, L. Lucas
Interface utilisateur
Dépend de :
Variables Globales / Champs Publics :
Fonctions et opérateur :
construire(acreer ex ParcLstS de X, l ex LstS) création d’un « parcoureur » de liste à partir de l
construire(acreer ex ParcLstS de X, pl ex ParcLstS de X) clonage d’un « parcoureur »
op = (dst ex ParcLstS de X, src ex ParcLstS de X) res ex ParcLstS de X
réaffecteur
p 1/2
Seconde approche
vision partagée
Dpt Info, L. Lucas
Autres fonctions :
Début (l ex ParcLstS de X) res nouv B position courante au début
Fin (l ex ParcLstS de X) res nouv B position courante à la fin
AjoutPosCrt (l ex ParcLstS de X, x nouv X) Ajout d’un élément x
Déroutable par ErrAllocationMémoire en position courante
AjoutAvPrec (l ex ParcLstS de X, x nouv X) Ajout d’un élément x
Déroutable par ErrAllocationMémoire avant le précédent
AjoutApSuiv (l ex ParcLstS de X, x nouv X) Ajout d’un élément x
Déroutable par ErrAllocationMémoire après le suivant
Suppression (l ex ParcLstS de X, prec nouv B) Déroutable par ErrListeVide
AccésProchain (l ex ParcLstS de X) res ex X Déroutable par ErrFinListe
AllerDébut (l ex ParcLstS de X) Déroutable par ErrListeVide
écrire Inutile
saisir Inutile
p 2/2
Dpt Info, L. Lucas
Interface utilisateur
Dépend de :
Variables Globales / Champs Publics :
Fonctions et opérateur :
construire(acreer ex ParcLstD de X, l ex LstD) création d’un « parcoureur » de liste à partir de l
construire(acreer ex ParcLstD de X, pl ex ParcLstD de X) clonage d’un « parcoureur »
op = (dst ex ParcLstD de X, src ex ParcLstD de X) res ex ParcLstD de X
réaffecteur
p 1/2
Seconde approche
vision partagée
Dpt Info, L. Lucas
Autres fonctions :
Début (l ex ParcLstD de X) res nouv B position courante au début
Fin (l ex ParcLstD de X) res nouv B position courante à la fin
AjoutPosCrt (l ex ParcLstD de X, x nouv X) Ajout d’un élément x
Déroutable par ErrAllocationMémoire en position courante
AjoutAvPrec (l ex ParcLstD de X, x nouv X) Ajout d’un élément x
Déroutable par ErrAllocationMémoire avant le précédent
AjoutApSuiv (l ex ParcLstD de X, x nouv X) Ajout d’un élément x
Déroutable par ErrAllocationMémoire après le suivant
Suppression (l ex ParcLstD de X, prec nouv B) Déroutable par ErrListeVide
AccésProchain (l ex ParcLstD de X) res ex X Déroutable par ErrFinListe
AccésPrécédent (l ex ParcLstD de X) res ex X Déroutable par ErrFinListe
AllerDébut (l ex ParcLstD de X) Déroutable par ErrListeVide
AllerFin (l ex ParcLstD de X) Déroutable par ErrListeVide
écrire Inutile
saisir Inutile
p 2/2
Dpt Info, L. Lucas
Dpt Info, L. Lucas
Dpt Info, L. Lucas
De façon général, les traitements sur les listes (simplement comme doublement chaînées) restent identiques dans leurs approches algorithmiques. On retrouve les mêmes fonctionnalités.
La gestion d’une liste est par contre amenée à changer. Cette dernière nécessitera au minimum l’utilisation un type LstS de X auquel on pourra lui adjoindre autant de de type ParcLstS de X.
Structures de Données
Dpt Info, L. Lucas
Dpt Info, L. Lucas
La PILE implante un conteneur particulier au regard des deux précédents. Contrairement aux listes et aux tables, elle ne sert généralement pas à conserver de façon définitive des informations (contenant hautement volatile). On s’intéresse plutôt à la suite des états de la pile en utilisant le fait que le dernier élément ajouté se trouve au sommet de la pile, afin de pouvoir être atteint le premier.
Dpt Info, L. Lucas
La stratégie de gestion d’une PILE repose sur la relation « dernier arrivé, premier sorti ». En anglais on dira Last In First Out (LIFO).
Dpt Info, L. Lucas
Définition des primitives d’accés
Une pile est structure linéaire, telle que le passage d ’un état au suivant se fait par adjonction ou suppression d’un élément en tête. Une pile est généralement schématisé par une suite chronologique de ses états :
sommet
base
Dpt Info, L. Lucas
conclusion
Bien que théoriquement de taille infinie, une pile est toujours dans la pratique, formée d’un nombre fini d’éléments qui correspond à la taille maximale de la pile. Cette taille maximale est selon le type d ’implémentation explicitée ou non.
PILE
TABLE
LISTE
Taille limitée uniquement
Dpt Info, L. Lucas
Interface utilisateur
Dépend de :
Variables Globales / Champs Publics :
construire(acreer ex Pile de X, l ex Pile de X)
op = (dst ex Pile de X, src ex Pile de X) res ex Pile de X
constructeur par copie et réaffecteur
(recopie des éléments)
Déroutable par ErrAllocationMémoire
détruire (adet ex Pile de X) destructeur (libère espace alloué)
p 1/2
Dpt Info, L. Lucas
Autres fonctions :
Vide (p ex Pile de X) res nouv B Pile p vide
Empiler (p ex Pile de X, x nouv X) Empile l’élément x
Déroutable par ErrAllocationMémoire
Dépiler (p ex Pile de X) res nouv X Dépile élément en sommet de p
Déroutable par ErrPileVide
Sommet (p ex Pile de X) res ex X Retourne le sommet de p
Déroutable par ErrPileVide
Vider (p ex Pile de X) Remise à zéro de p
écrire Indisponible, utiliser la fonction écrire du type X
saisir Indisponible, utiliser la fonction saisir du type X
p 2/2
Dpt Info, L. Lucas
Dpt Info, L. Lucas
Dpt Info, L. Lucas
4
Elem
12
23
8
Tête
4
Elem
Dpt Info, L. Lucas
4
12
23
8
4
sommet
sommet
Dpt Info, L. Lucas
4
12
23
8
Tête
Elem
Dpt Info, L. Lucas
Dpt Info, L. Lucas
conclusion
Les applications utilisant des piles sont nombreuses. On peut citer à titre d’exemple :
l’évaluation de fonctions récursives,
les parcours arborescents,
...
L ’évaluation de (A+(C*D)) avec A=3, C=4 et D=5 passe par les étapes suivantes:
évaluation((A+(C*D))) = opération(+,3,(évaluation((C*D)))
= opération(+,3,opération(*,4,5))
= opération(+,3,20)
= 23
Dpt Info, L. Lucas
Dpt Info, L. Lucas
La FILE implante un conteneur dont le comportement est celui d ’une file d’attente. Les premiers individus d ’une file d’attente sont servis les premiers.
Ces files d ’attente sont d’un usage très répandu dans la programmation système, où elles servent à gérer, par exemple, l’allocation des ressources.
Une File d’attente est une structure linéaire telle que
les insertions sont toujours effectuées en fin,
les suppressions sont toujours effectuées en tête.
Dpt Info, L. Lucas
La stratégie de gestion d’une FILE repose sur la relation « premier arrivé, premier sorti ». En anglais on dira Fisrt In First Out (FIFO).
Dpt Info, L. Lucas
conclusion
La taille d’une file d’attente est, comme pour une pile, dépendante du type sous-jacent. Une vision contiguë limitera par défaut la taille de la file, alors qu’une vision chaînée ne sera limitée intrinsèquement que par la capacité mémoire de l’ordinateur.
FILE
TABLE
LISTE
Taille limitée uniquement
Dpt Info, L. Lucas
Interface utilisateur
Dépend de :
Variables Globales / Champs Publics :
construire(acreer ex File de X, l ex File de X)
op = (dst ex File de X, src ex File de X) res ex File de X
constructeur par copie et réaffecteur
(recopie des éléments)
Déroutable par ErrAllocationMémoire
détruire (adet ex File de X) destructeur (libère espace alloué)
p 1/2
Dpt Info, L. Lucas
Autres fonctions :
Vide (f ex File de X) res nouv B File f vide
Enfiler (f ex File de X, x nouv X) Enfile l’élément x
Déroutable par ErrAllocationMémoire
Défiler (f ex File de X) res nouv X Défile élément en sommet de f
Déroutable par ErrFileVide
Sommet (f ex File de X) res ex X Retourne le sommet de f
Déroutable par ErrFileVide
Vider (f ex File de X) Remise à zéro de f
écrire Indisponible, utiliser la fonction écrire du type X
saisir Indisponible, utiliser la fonction saisir du type X
p 2/2
Dpt Info, L. Lucas
Dpt Info, L. Lucas
Dpt Info, L. Lucas
4
Elem
Dpt Info, L. Lucas
4
12
23
8
4
sommet
sommet
base
base
Dpt Info, L. Lucas
4
12
23
8
Tête
Elem
Dpt Info, L. Lucas
Dpt Info, L. Lucas
Dpt Info, L. Lucas
conclusion
La représentation chaînée est plus encombrante que la représentation contiguë et l’accès à un élément est également moins rapide. Par contre, une mise à jour ne nécessitant aucune recopie, son coût est moins élevé que dans le cas d’une représentation contiguë. On choisit une représentation chaînée chaque fois que les mises à jour sont plus importantes que les consultations et une représentation contiguë chaque fois que les consultations l’emportent sur les mises à jour.
Dans la pratique, on utilise très souvent des structures mixtes composées de listes et de tables.
Structures de Données
objet «
pointé
Dpt Info, L. Lucas
algorithmiques relatifs aux Structures de
Données autrement appelées Conteneurs.
Dpt Info, L. Lucas
Conteneurs linéaires : TABLES & LISTES
Dpt Info, L. Lucas
définition
généricité
conclusion
Dpt Info, L. Lucas
généricité
Un conteneur, ou collection, est un objet qui réalise une structure de données qui « contient » d’autres objets.
Les conteneurs fondamentaux sont :
Dpt Info, L. Lucas
généricité
La puissance apportée par la Conception Objet ne vient pas tant de ce que celle-ci sait faire, mais plutôt de ce qu’elle est capable d’apprendre.
Autrement dit, la logique de gestion du conteneur étant indépendante du contenu, on ne s ’attachera qu’à définir le comportement du conteneur.
L ’outil privilégié qu’offre la Conception Objet est la
GENERICITE Factorisation du type contenu
Dpt Info, L. Lucas
généricité
La spécification d ’un conteneur pose deux questions essentielles, auxquelles il est nécessaire de répondre :
Le conteneur est-il homogène ou hétérogène ?
Dpt Info, L. Lucas
Homogène ou Hétérogène ?
Un conteneur qui contient des objets d ’un seul type est dit homogène.
Dpt Info, L. Lucas
Sémantique de référence ou de valeur ?
Dpt Info, L. Lucas
Sémantique de valeur
Aucun objet n’est contenu dans deux conteneurs ou plus ( il n’y a pas de partage).
Un objet est copié dans un conteneur ; si vous dites
Allouer ConteneurVal de Chose conteneur
construire (conteneur)
conteneur.ajout(t)
une nouvelle Chose est créée dans le conteneur (constructeur par copie). Les modifications futures de la Chose dans le conteneur n ’affecteront pas t et inversement.
Dpt Info, L. Lucas
Sémantique de référence
Un objet peut être « dans » plus d ’un conteneur puisque chaque conteneur contient juste une référence sur l’objet.
Mettre un objet dans un conteneur ne nécessite pas une copie de l ’objet.
Lorsque le conteneur est détruit, les objets qu’il contient ne sont pas détruits.
Dpt Info, L. Lucas
Hétérogène avec une sémantique par valeur
Ces conteneurs sont difficiles à concevoir.
Dpt Info, L. Lucas
Homogène avec une sémantique par valeur
Les patrons ou types paramètrés supportent directement ce type de conteneur.
Cf. Généricité et Cours de Y. Rémion
Dpt Info, L. Lucas
Sémantique par référence (homogène ou hétérogène)
Ce type de conteneur repose sur l ’utilisation de pointeurs qui permettent le partage par plusieurs conteneurs d’un même objet. Pour un conteneur hétérogène, les pointeurs pointent sur une classe de base commune ; cela permet d’ajouter dans le conteneur des pointeurs sur des classes dérivées.
Dpt Info, L. Lucas
généricité
Dpt Info, L. Lucas
généricité
Principe
Un algorithme classique est, la plupart du temps, dépendant des données qu’il manipule. Toute modification de ces données, même minime, peut engendrer des effets de bords indésirables.
La démarche Objet permet de dissocier l’algorithme des données sur lesquelles il opère.
Dpt Info, L. Lucas
Algorithmes génériques
Plus généralement, un outil générique est un outil dans lequel certaines informations n’ont pas été précisées et devront l’être plus tard.
Classe A
Dpt Info, L. Lucas
Concevoir « générique »
Dans beaucoup de cas, l’algorithme que l’on recherche existe déjà sur d’autres types de données. Le choix d’implémentation est alors :
soit de le transposer sur le nouveau type d ’objets,
soit de le rendre générique, puis l ’instancier sur le
nouveau type d ’objets.
Dpt Info, L. Lucas
Le premier choix repose sur une vision algorithmique conventionnelle (copier-coller). Il impose une réécriture systématique de l ’algorithme, dès lors que le type varie.
Dpt Info, L. Lucas
Dpt Info, L. Lucas
Conteneurs Linéaires
En résumé :
Une classe est générique si un ou plusieurs des types d’objets qui y sont employés ne sont pas encore définis, et devront donc être spécifiés ultérieurement lors de l’instanciation de la classe.
L’intérêt de passer par une conception générique d’un conteneur, quel que soit son type, va permettre de focaliser toute l ’attention du concepteur sur les moyens que devra mettre en œuvre ce conteneur.
Structures de Données
Dpt Info, L. Lucas
piles et files
conclusion
Dpt Info, L. Lucas
conclusion
Introduction
Les applications usuelles de l’informatique sont appelées à traiter des collections d’objets construites en assemblant quantité d ’objets homogènes.
L’exemple le plus banal de ces collections est fourni par les conteneurs linéaires dans lesquels les objets d’un même type sont déposés les uns à côté des autres.
COLLECTION
Dpt Info, L. Lucas
& sous sa forme mémoire
« objets d’un même type sont déposés les uns à côté des autres »
0
1
2
3
2
0
1
3
COLLECTION
Dpt Info, L. Lucas
conclusion
Introduction
Le choix de la structure de données sous-jacente dépend alors de l ’usage du conteneur.
Si l’objectif majeur du conteneur repose sur ses performances à l’exécution, un conteneur de type TABLE se présentera comme le meilleur compromis.
Si celui-ci s’insère dans un traitement où les éléments sont fréquemment insérés ou supprimés rien n’interdit d’opter pour un conteneur de type LISTE, ce dernier étant réhabillé de sorte que l ’utilisateur le perçoive comme une table.
Structures de Données
Dpt Info, L. Lucas
conclusion
Introduction
L’intérêt de la COO permet ici de cacher la gestion interne du conteneur. Le choix d ’implémentation de tel ou tel conteneur est un acte qui relève du concepteur de l’application.
Structures de Données
Dpt Info, L. Lucas
conclusion
La TABLE implante un conteneur dans lequel les objets d’un même type sont déposés les uns à côté des autres, dans des espaces mémoires contigus.
Accès direct aux objets de rang n est une fonctionnalité naturelle pour ce type de conteneur,
Moyen de stockage simple quand la « volatilité » des objets contenus est faible (peu insertion ou peu de suppression),
Structure statique. A savoir que l’opération de re-dimensionnement impose pour l ’utilisateur un choix volontariste et pour le concepteur, une opération explicite.
Structures de Données
Dpt Info, L. Lucas
Interface utilisateur
Dépend de :
Variables Globales / Champs Publics :
Fonctions et opérateur :
construire(acreer ex Tab de X, n nouv N, z nouv Z, x nouv X)
indéxée par [z,z+n[
construire(acreer ex Tab de X, n nouv N, x nouv X)
indéxée par [0,n[
indéxée par [0,1[
construire(acreer ex Tab de X, t cons Tab de X)
op = (acreer ex Tab de X, t cons Tab de X) res ex Tab de X
constructeur par copie et réaffecteur
(même espace d’indexation allocation
même taille recopie des éléments)
détruire(adet ex Tab de X) destructeur (libère espace alloué)
p 1/2
Dpt Info, L. Lucas
Autres fonctions :
IndexPremierElem (t cons Tab de X) res nouv Z Index de début
IndexDernierElem (t cons Tab de X) res nouv Z Index de fin
(dernier utilisé : z+n-1)
NombreElem (t cons Tab de X) res nouv N n
IndexValide (t cons Tab de X) res nouv B
Déroutable par ErrIndexInvalide
z dans espace indexation de t ?
op [ ] (t ex Tab de X, Z nouv z) res ex X
Déroutable par ErrIndexInvalide
écrire Indisponible, utiliser la fonction écrire du type X
saisir Indisponible, utiliser la fonction saisir du type X
p 2/2
Dpt Info, L. Lucas
n nouv N,
z nouv Z,
x nouv X)
Taille de la table
Indice du premier élément
Dpt Info, L. Lucas
construire (tb, 8, 2, N éphémère (8))
2
3
4
5
6
7
8
9
construire (tb, 8, N éphémère (3))
0
1
2
3
4
5
6
7
Dpt Info, L. Lucas
0
construire (tout, tin)
Dpt Info, L. Lucas
réserver un espace mémoire de nb X,
maintenir l’adresse retournée,
initialiser l’indice de la première occurrence.
Le mécanisme mis en œuvre est comparable à la création d’objets durables non nommés (Cf. Cours Algo) pour lequel on va :
réserver nb espace(s) mémoires contigus typés de type X,
mémoriser l ’adresse du premier élément.
Structures de Données
Dpt Info, L. Lucas
conclusion
Il est utile de savoir créer des objets non nommés durables (nb et valeurs inconnus à la compilation)
Pour ce faire les méta-fonctions suivantes seront supposées exister pour tout type T et toute liste de paramètres licite pour construire un T :
T durable ( paramètres ) res nouv Adr de T
début Allouer T t
Structures de Données
Dpt Info, L. Lucas
construire (tb, 8, 2, N éphémère (8))
2
3
4
5
6
7
8
9
réserver sur le tas un espace mémoire de nb X,
maintenir l’adresse retournée,
initialiser l’indice de la première occurrence.
& Res nouv Adr de X
Structures de Données
Dpt Info, L. Lucas
Recyclage des erreurs à la construction
La réservation de Xs durables est ici explicitement définie par le concepteur de la classe Tab. Cette étape est susceptible de provoquer des erreurs qu’il est obligatoire de prendre en compte.
Mise en place d’un mécanisme d’exception adapté
ErrAllocationMémoire
Structures de Données
Dpt Info, L. Lucas
conclusion
construire (acreer ex Tab de X, n nouv N, x ex X)
Déroutable par ErrAllocationMémoire
Si « réservation des n Xs est effectuée sans anomalie » Alors
Deb
Recyclage des erreurs à la construction
Structures de Données
Dpt Info, L. Lucas
Le destructeur
Cette fonctionnalité doit veiller à restituer l’ensemble de la mémoire consommée par la table adet.
détruire (adet ex Tab de X)
Son objectif consiste à :
détruire les instances de adet,
rendre l’espace mémoire affecté à ces instances, ce qui revient à oublier l’adresse retournée lors de la construction de adet
Structures de Données
Dpt Info, L. Lucas
Le réaffecteur
op = (dst ex Tab de X, src ex Tab de X)
res ex Tab de X
Déroutable par ErrAllocationMémoire
allouer dst (cf. Constructeur par copie)
copier le contenu de src dans dst (cf. Constructeur par copie).
Structures de Données
Dpt Info, L. Lucas
res ex X
Déroutable par ErrIndexInvalide
construire (tb, 8, 2, N éphémère (8))
2
3
4
5
6
7
8
9
Dpt Info, L. Lucas
Dpt Info, L. Lucas
Son principe algorithmique repose sur :
identification de l ’adresse Adr1 de X d ’implantation mémoire de la table,
décalage par rapport à cette adresse de
Adr2 de X = Adr1 de X + index * taille_de(X)
déréférencement d ’un X en Adr2 de X,
Structures de Données
Dpt Info, L. Lucas
Adr de T
Rôle : Pointeur de T, objet mémorisant l ’adresse d ’un objet de type T, on dit aussi « pointant sur » un objet de type T.
Interface utilisateur
Dépend de :
Fonctions et opérateurs :
construire (ex Adr de T, ex Adr de T) constructeur par copie
détruire (ex Adr de T) destructeur
op = (ex Adr de T,
nouv Adr de T) ex Adr de T réaffecteur
construire (ex Adr de T) constructeur par défaut
adresse illicite (0)
Adresse (t ex T) nouv Adr de T pointage de t,adresse de t
Contenu (a nouv Adr de T) ex T objet « pointé » par a,
objet de type T à l‘adresse a
IUT Léonard de Vinci, Reims
Dpt Info, L. Lucas
8
8
8
8
8
6
8
8
construire (tb, 8, 2, N éphémère (8))
2
3
4
5
6
7
8
9
8
Dpt Info, L. Lucas
construire (tb, 8, 2, N éphémère (0))
écrire (IndexPremierElem(tb), OUT)
écrire (IndexDernierElem(tb), OUT)
écrire (NombreElem(tb), OUT)
Dpt Info, L. Lucas
Problème du parcours d’une TABLE
L’idée la plus simple consiste à parcourir la table dans l’ordre croissant de ses indices. On obtient ainsi le schéma d’énumération séquentiel “de gauche à droite” des éléments de la table.
Allouer Z i
construire (tb, 8, 2, N éphémère (8))
construire (i, IndexPremierElem (tb))
deb
Dpt Info, L. Lucas
Algorithmes d’accès à un élément d’une TABLE
Soit une table T[imin … imax]. L’accès par position est défini par la fonction d’indexation T[i]. L’accès associatif est le plus courant. Soit elem une variable contenant une valeur de même type que celles contenues dans T, on veut déterminer s’il existe un indice i [imin … imax] tel que T[i] = elem.
Cet accès peut être réalisé de plusieurs manières suivant que l’on suppose T trié ou non.
Structures de Données
Dpt Info, L. Lucas
Raisonnement par récurrence :
Supposons traités les i-1 ( [z < i < z + n[ ) premiers éléments de la table T, et que elem T[z … i-1].
i = z + n elem T[z … z + n[
l’algorithme est terminé, elem T.
i < z + n
T[i] = elem elem [z … z + n[, l’algorithme est terminé, elem T
T[i] elem elem T[z … i], l ’exécution de l ’instruction i = i + 1 permet de déclencher l’assertion elem T[z … i-1].
Structures de Données
Dpt Info, L. Lucas
Initialisation
l’action i = z permet de déclencher l ’assertion précédente
Progression
INVARIANT
vrai vrai vrai
vrai faux faux
Dpt Info, L. Lucas
Phase de progression
i = z + n
Dpt Info, L. Lucas
5
3
0
7
8
1
6
4
construire (tb, 8, 2, N éphémère (0))
…
2
3
4
5
6
7
8
9
2 faux faux
3 faux faux
4 faux faux
5 faux faux
6 faux faux
7 faux faux
8 faux faux
9 faux faux
Dpt Info, L. Lucas
5
3
0
7
8
1
2
4
construire (tb, 8, 2, N éphémère (0))
…
2
3
4
5
6
7
8
9
2 faux faux
3 faux faux
4 faux faux
5 faux faux
6 vrai vrai
Dpt Info, L. Lucas
Version récursive / parcours de gauche à droite
RechercheR (tb ex Tab de T, elem nouv T) res nouv B
Début
Fin
recherche (tb ex Tab de T, z nouv Z, elem nouv T) res nouv B
Début
sinon si tb[z] == elem
alors construire (res, B éphémère (Vrai))
sinon construire (res, recherche (tb, z + 1, elem))
Fin
Dpt Info, L. Lucas
Version récursive / parcours de droite à gauche
RechercheR (tb ex Tab de T, elem nouv T) res nouv B
Début
Fin
recherche (tb ex Tab de T, z nouv Z, elem nouv T) res nouv B
Début
sinon si tb[z] == elem
alors construire (res, B éphémère (Vrai))
sinon construire (res, recherche (tb, z - 1, elem))
Fin
Dpt Info, L. Lucas
Recherche séquentielle / TABLE triée
Si tous les éléments consécutifs d’une table vérifient la relation d’ordre
T[i-1] T[i]
on dit que la table est triée par ordre croissant (ou ordonnée). On admettra qu’une table vide ou qu’une table ne contenant qu’un seul élément sont aussi triées.
Structures de Données
Dpt Info, L. Lucas
une table T (NombreElem(T) = 1) est ordonnée
une table T[ … ] avec < est ordonnée si
i [+1 … ], T[i-1] T[i]
une table T vide (NombreElem(T) = 0) est ordonnée
une table T (NombreElem(T) = 1) est ordonnée
T[ … i-1] est ordonnée, T[i-1] T[i]
T[ … i] est ordonnée pour i [+1 … ]
Structures de Données
Dpt Info, L. Lucas
T[ … i-1] < elem T[i … ]
soit une assertion
Dpt Info, L. Lucas
l’action i = z permet de déclencher l ’assertion précédente
Progression
INVARIANT
vrai vrai vrai
vrai faux faux
Dpt Info, L. Lucas
construire (tb, 8, 2, N éphémère (0))
…
2
3
4
5
6
7
8
9
2 faux faux
3 faux faux
4 faux faux
5 faux faux
6 vrai vrai
Dpt Info, L. Lucas
construire (tb, 8, 2, N éphémère (0))
…
2
3
4
5
6
7
8
9
2 faux faux
3 faux faux
4 faux faux
5 faux faux
Dpt Info, L. Lucas
Recherche dichotomique / TABLE triée
On partitionne la table T en trois sous-tables T[imin … m-1], T[m … m], T[m+1 … imax] ordonnées. Cette partition vérifie la relation :
T[imin … m-1] T[m … m] T[m+1 … imax]
En comparant elem à T[m], on peut décider à quel sous-table appartient elem si elem T[m] soit :
T[imin … m-1] si elem < T[m]
T[m+1 … imax] si elem > T[m]
Structures de Données
Dpt Info, L. Lucas
On est donc ramené au même problème que précédemment :
rechercher elem dans une table (T[imin … m-1] ou T[m+1 … imax]).
Par contre si elem = T[m] l ’algorithme est terminé
Structures de Données
Dpt Info, L. Lucas
m
inf
sup
elem T
algorithme terminé
inf <= sup
Dpt Info, L. Lucas
Raisonnement par récurrence :
Supposons T[z … inf-1] elem T[sup+1 ... z+n[, non trouvé.
inf = sup + 1 elem T, résultat = Faux
inf sup
T[m] > elem sup = m - 1
T[m] < elem inf = m + 1
Itération : tantque inf sup Et non trouve
Initialisation : inf = IPE(T), max = IDE(T)
trouve = Faux
Dpt Info, L. Lucas
construire (tb, 8, 2, N éphémère (0))
…
2
3
4
5
6
7
8
9
init 2 9 V F
1 2 4 5 V F
2 3 V V
Dpt Info, L. Lucas
construire (tb, 8, 2, N éphémère (0))
…
2
3
4
5
6
7
8
9
init 2 9 V F
1 6 9 5 V F
2 8 9 7 V F
3 9 9 8 V F
4 10 9 9 F F
Structures de Données
Dpt Info, L. Lucas
Algorithmes de tris d’une TABLE
Soit une table T[imin … imax] à valeurs dans un ensemble E de valeurs muni d’une relation d’ordre notée <. Trier la table T consiste à construire une table T’[imin … imax] tel que :
T’ soit triée,
Structures de Données
Dpt Info, L. Lucas
Dpt Info, L. Lucas
Tri par remplacement
On veut construire une table triée T’[imin … imax] à partir de T[imin … imax] tel que
T’[i-1] T’[i], i [imin+1 … imax]
Pour i= imin+1, on a donc :
T’[imin] T’[imin+1 … imax]
T’[imin] = minimum(T[imin … imax] )
Structures de Données
Dpt Info, L. Lucas
ajout du minimum dans T’
substitution du minimum de T par la valeur majorante de T
valeur majorante = maximum(T)
Structures de Données
Dpt Info, L. Lucas
Tri par remplacement
Raisonnement par récurrence :
Supposons T’[z … i-1] triée, T’[z … i-1] T[z ... z+n[, et max = maximum(T[z ... z+n[).
i = z + n - 1 T’ est triée, T ’[z … z+n-2] T[z ... z+n[
T’[z + n - 1] = max
i < z + n - 1
Soit j tel que T[j] = minimum(T[z ... z+n])
T’[i] = T[j], T[j] = max, i = i + 1.
Itération : tantque i < IndexDernierElement (T)
Initialisation : i = 1, max = maximum(T)
Structures de Données
Dpt Info, L. Lucas
Tri par remplacement
Exemple : trier dans l ’ordre alphabétique les lettres du mot « TABLEAUX ». Le maximum est égal à ‘ X ’.
j [1,8]
Dpt Info, L. Lucas
Début
Allouer N i, j
Structures de Données
Dpt Info, L. Lucas
Supposons max T [z … i-1], max T[z ... i-1].
i = z + n max T[z ... z+n[, max T[z ... Z+n[
résultat = max
T[i] max i = i + 1
Itération : tantque i < IndexDernierElement (T)
Initialisation : max = T[IndexPremierElement(T)]
Dpt Info, L. Lucas
Début
i = i + 1
Structures de Données
Dpt Info, L. Lucas
Supposons j [z … i-1], T[j] T[z ... i-1].
i = z + n j [z … z+n[, T[j] T[z ... z+n[
résultat = j
T[j] T[i] i = i + 1
Itération : tantque i IndexDernierElement (T)
Initialisation : i = IndexPremierElement(T), i = j + 1
Structures de Données
Dpt Info, L. Lucas
Début
i = i + 1
Structures de Données
Dpt Info, L. Lucas
Supposons traités i-1 (imin i imax) éléments de T.
On peut donc considérer la table T comme la concaténation de 2 sous-tables : la sous-table T[imin … i-1] dont les éléments sont triés, et la sous-table T[i … imax] dont les éléments n’ont pas encore été traités. D ’autre part tous les éléments de la sous-table T[imin … i-1] sont inférieurs ou égaux à tous les éléments de la sous-table T[i … imax].
imin
imax
i
i-1
triée
Dpt Info, L. Lucas
j [1,7]
Exemple : trier dans l ’ordre alphabétique les lettres du mot « BATEAUX ».
T
Dpt Info, L. Lucas
Raisonnement par récurrence :
Supposons T[z … i-1] triée, T[i … z+n[ non traitée
et T[z … i-1] T[i … z+n[.
i = z + n - 1 T[i] non traité, T[z … i-1] T[z+n-1]
T[z … i-1] est triée, T[z … z+n[ est aussi triée
i < z + n - 1
Soit j tel que T[j] = minimum de T[i … z+n[, j [i … z+n[
j = i i = i + 1
j i permuter T[j] avec T[i], i = i + 1
Itération : tantque i < IndexDernierElement(T)
Dpt Info, L. Lucas
Supposons traités i-1 (imin i imax) éléments de T.
On retrouve la situation que nous avons déjà vue dans la méthode précédente. Pour augmenter la sous-table triée d’un élément, il faut chercher le plus petit élément contenu dans la sous-table non traitée et le placer en position i. Nous allons cette fois, au lieu de la recherche du minimum suivie d’une permutation, utiliser la méthode dite des bulles.
imin
imax
i
i-1
triée
Dpt Info, L. Lucas
conclusion
On parcourt la sous-table T[i … imax] de droite à gauche et, chaque fois qu’il y a deux éléments consécutifs qui ne sont pas dans l’ordre, on les permute. Cette opération permet d’obtenir en fin de parcours le plus petit élément de T [i … imax] placé en position i.
Structures de Données
Dpt Info, L. Lucas
j [1,7]
Exemple : trier dans l ’ordre alphabétique les lettres du mot « BATEAUX ».
T
A
A
B
E
T
U
fini
Dpt Info, L. Lucas
Raisonnement par récurrence :
Supposons T[z … i-1] triée, T[i … z+n[ non traitée
et T[z … i-1] T[i … z+n[.
i = z + n - 1 T[z … i-1] est triée, T[z … i-1] T[z+n-1]
T[z … z+n[ est aussi triée
i < z + n - 1
Permutations (« bulles ») de telle sorte que le minimum de T[i … z+n[ soit placé en T[i], i = i + 1
Itération : tantque i < IndexDernierElement(T)
Dpt Info, L. Lucas
Tri à bulles / optimisation de l ’algorithme
A
A
B
fini
Dpt Info, L. Lucas
Supposons traités i-1 (imin i imax) éléments de T.
Il suffit d’insérer l’élément T[i] dans la sous-table déjà trié pour augmenter celle-ci d’un élément. Il s ’agit donc d’ajouter à la sous-table triée un nouvel élément elem, qui est dans le même temps supprimé de la sous-table non traitée.
imin
imax
i
i-1
triée
Dpt Info, L. Lucas
j [1,7]
Exemple : trier dans l ’ordre alphabétique les lettres du mot « BATEAUX ».
T
AB/TEAUX
ABT/EAUX
ABET/AUX
AABET/UX
AABETU/X
AABETUX/
fini
Dpt Info, L. Lucas
Raisonnement par récurrence :
Supposons T[z … i] triée, T[i+1 … z+n[ non traitée.
i = z + n - 1 T[z … z+n[ est triée
i < z + n - 1 insertion (T[z … i], T[i+1])
Itération : tantque i < IndexDernierElement(T)
Dpt Info, L. Lucas
Ttrié[i] elem p = i +1
Ttrié[i] > elem i = i - 1
Itération : tantque Ttrie[i] > elem
Initialisation : si Ttrié[IPE(T)] > elem alors p = 1
sinon i = n
Tri par insertion
Dpt Info, L. Lucas
conclusion
Il s’agit d’un algorithme qui se présente sous plusieurs versions ayant toutes, dans le cas général, de meilleures performances que les algorithmes précédents. Il est basé sur le principe de « diviser pour régner » que nous avons déjà utilisé dans l’algorithme de recherche dichotomique.
Structures de Données
Dpt Info, L. Lucas
conclusion
Supposons que nous ayons à trier une table T[inf … sup] avec inf < sup. Nous allons segmenter cette table en trois sous-tables telles que :
tous les éléments se trouvant à gauche de place (place [inf … sup] soient inférieurs ou égaux à T[place] et que ceux se trouvant à doite de place soient supérieurs à T[place].
place
inf
sup
Dpt Info, L. Lucas
et on constate
que T[place] est correctement rangé,
qu’il ne reste plus qu’à trier les deux sous-tables.
T[inf … place-1] et T[place+1 … sup]
Structures de Données
Dpt Info, L. Lucas
conclusion
TriSegmentation(T ex Tab de X, inf nouv Z, sup nouv Z)
Début
fin
Fin, Eliminer place, inf, sup Oublier T
Pour trier T, il suffit d’appeler la fonction TriSegmentation de la façon suivante : TriSegmentation (T, IPE(T), IDE(T))
Structures de Données
Dpt Info, L. Lucas
Supposons T[inf … i-1] pivot < T[j+1 … sup]
i = j + 1 permutation de T[inf] avec T[j], place = j
i j
T[i] pivot i = i + 1
T[i] > pivot permuter T[i] avec T[j], j = j - 1
Itération : tantque i j
Structures de Données
Dpt Info, L. Lucas
& sous sa forme mémoire
« objets d’un même type sont déposés les uns à côté des autres »
0
1
2
3
2
0
1
3
COLLECTION
Dpt Info, L. Lucas
conclusion
La LISTE implante un conteneur dans lequel les objets d’un même type sont déposés les uns à côté des autres, dans des espaces mémoires non contigus.
Structure dynamique. A savoir que l’opération de re-dimensionnement n’impose pas pour l’utilisateur un choix particulier,
Moyen de stockage simple quand la « volatilité » des objets contenus est importante (insertion / suppression nombreuses),
Accès direct aux objets de rang n impose un balayage systématique du conteneur.
Structures de Données
Dpt Info, L. Lucas
conclusion
La LISTE chaînée se présente comme l ’autre alternative à l’utilisation de TABLE. Elle fournit sensiblement le même service, en rassemblant une suite d’éléments, mais n’oblige pas ces éléments à rester concaténés physiquement en mémoire. Elle permet de faire disparaître un élément de milieu de liste aussi facilement qu’un élément en début ou fin de liste.
STRUCTURE HAUTEMENT DYNAMIQUE
Structures de Données
Dpt Info, L. Lucas
conclusion
La gestion dynamique (de la mémoire) doit donc nous permettre de faire apparaître, puis disparaître, comme bon nous semble, des objets anonymes.
En reliant ces objets les uns aux autres, nous pouvons développer des structures de données (conteneurs) non contigus
Structures de Données
Dpt Info, L. Lucas
conclusion
Définition
Une liste chaînée est une structure composée d’éléments chaînés les uns aux autres. Le chaînage entre deux de ces éléments s’obtient en plaçant dans l’un des deux élément (ou dans les deux), un lien faisant référence à l’autre.
Pour avoir accès à l’ensemble des éléments de la liste, il suffit de posséder l’adresse du premier dans le cas d’un simple chaînage.
5
23
9
16
7
18
Tête
Dpt Info, L. Lucas
Modes de chaînage
Le chaînage d’une liste peut se présentes de différentes manières. Les plus communes sont les suivantes :
5
23
9
16
7
18
Tête
5
23
9
16
7
18
Tête
Queue
5
23
9
16
7
18
Tête
Queue
Dpt Info, L. Lucas
Représentation d’un élément
On définit un élément (cellule / nœud) dans le cas d’une liste simplement chaînée, comme un couple composé d’une information de type X et un pointeur (élément de X) contenant l’adresse de l’élément suivant.
X
Adresse
Dpt Info, L. Lucas
Gestion dynamique de la mémoire
Si on souhaite conserver certains objets (ex. Cellule de X) de façon DURABLE, cela suppose la capacité d’obtenir du système des emplacements de mémoire vierges et bien sûr la capacité de les lui rendre, dès que leur besoin ne se fera plus sentir.
Dpt Info, L. Lucas
Gestion dynamique de la mémoire
Naturellement, pour être en mesure de gérer ces emplacements mémoire, il faut disposer d’objets capables de mémoriser des adresses mémoires. Ces objets sont les pointeurs.
Un objet de type pointeur peut contenir une adresse quelconque et donc « pointer » sur n’importe quel objet. Il s’agit donc bien d’un type générique.
Adresse de X ou Pointeur de X
Structures de Données
Dpt Info, L. Lucas
conclusion
Il est utile de savoir créer des objets non nommés durables (nb et valeurs inconnus à la compilation)
Pour ce faire les méta-fonctions suivantes seront supposées exister pour tout type T et toute liste de paramètres licite pour construire un T :
T durable ( paramètres ) res nouv Adr de T
début Allouer T t
Structures de Données
Dpt Info, L. Lucas
Adr de T
Rôle : Pointeur de T, objet mémorisant l ’adresse d ’un objet de type T, on dit aussi « pointant sur » un objet de type T.
Interface utilisateur
Dépend de :
Structures de Données
Fonctions et opérateurs :
construire (ex Adr de T, ex Adr de T) constructeur par copie
détruire (ex Adr de T) destructeur
op = (ex Adr de T,
nouv Adr de T) ex Adr de T réaffecteur
construire (ex Adr de T) constructeur par défaut
adresse illicite (0)
Adresse (t ex T) nouv Adr de T pointage de t,adresse de t
Contenu (a nouv Adr de T) ex T objet « pointé » par a,
objet de type T à l‘adresse a
IUT Léonard de Vinci, Reims
Dpt Info, L. Lucas
Dpt Info, L. Lucas
Dpt Info, L. Lucas
Interface utilisateur
Dépend de :
Variables Globales / Champs Publics :
construire(acreer ex LstS de X, l ex LstS de X)
op = (dst ex LstS de X, src ex LstS de X) res ex LstS de X
constructeur par copie et réaffecteur
(recopie des éléments)
Déroutable par ErrAllocationMémoire
détruire (adet ex LstS de X) destructeur (libère espace alloué)
p 1/2
Première approche
vision propriétaire
Dpt Info, L. Lucas
Interface utilisateur
Dépend de :
Variables Globales / Champs Publics :
construire(acreer ex LstS de X, l ex LstS de X)
op = (dst ex LstS de X, src ex LstS de X) res ex LstS de X
constructeur par copie et réaffecteur
(recopie des éléments)
Déroutable par ErrAllocationMémoire
détruire (adet ex LstS de X) destructeur (libère espace alloué)
p 1/2
Première approche
vision propriétaire
Dpt Info, L. Lucas
Autres fonctions :
Vide (l ex LstS de X) res nouv B Liste l vide
Premier (l ex LstS de X) res ex X Premier élément de l
Déroutable par ErrListeVide MAJ position courante
Courant (l ex LstS de X) res ex X Retourne élément
Déroutable par ErrListeVide courant
Suivant (l ex LstS de X) res ex X Elément suivant la
Déroutable par ErrFinListe position courante
MAJ position courante
Ajout (l ex LstS de X, x nouv X) Ajout d ’un élément
Déroutable par ErrAllocationMémoire x par rapport à la
position courante
Déroutable par ErrListeVide l’élément courant
écrire Indisponible, utiliser la fonction écrire du type X
saisir Indisponible, utiliser la fonction saisir du type X
p 2/2
Dpt Info, L. Lucas
P_GD (l ex LstS de X) Déroutable par ErrFinListe, ErrListeVide
Début
Début
Fin Oublier l Eliminer tmp
L ’algorithme s’arrête lorsqu’il n’y a plus d’éléments à traiter
dérouter par ErrFinListe /ErrListeVide
Dpt Info, L. Lucas
parcoursgd (liste 1)
traiter (liste 1)
parcoursgd (liste 2)
traiter (liste 2)
parcoursgd (liste 3)
traiter (liste 3)
parcoursgd (liste 4)
traiter (liste 4)
traiter (liste i)
Dpt Info, L. Lucas
P_DG (l ex LstS de X) Déroutable par ErrFinListe, ErrListeVide
Début
Parcoursdg(l ex LstS de X) Déroutable par ErrFinListe
Début
Structures de Données
Dpt Info, L. Lucas
parcoursdg (liste 1)
parcoursdg (liste 2)
parcoursdg (liste 3)
parcoursdg (liste 4)
parcoursdg (liste i+1)
Dpt Info, L. Lucas
Parcoursgd(l ex LstS de X) Déroutable par ErrFinListe,
ErrListeVide
Début
début
Structures de Données
Dpt Info, L. Lucas
Longueur d’une liste / Schéma itératif
Supposons traités les n premiers éléments de la liste. On a la situation suivante :
n = long(L) où long désigne le nombre d ’éléments de la liste L.
5
23
9
16
7
18
Tête
L
Dpt Info, L. Lucas
L <>
Structures de Données
Dpt Info, L. Lucas
Structures de Données
Dpt Info, L. Lucas
=(1+(1+(1+(1+(1+long(L6))))))
=(1+(1+(1+(1+(1+(1+long(NULL)))))))
= 6
L1
L2
L3
L4
L5
L6
Dpt Info, L. Lucas
12
Elem
5
23
9
16
7
18
Tête
12
Elem
Dpt Info, L. Lucas
Démarche algorithmique
création d’une cellule de X durable d’adresse Elem
chaînage de la nouvelle cellule avec la liste (l’élément suivant de Elem Tête)
réaffectation de Tête (Tête = Elem)
Structures de Données
Dpt Info, L. Lucas
12
Elem
5
23
9
16
7
18
Tête
12
Elem
Dpt Info, L. Lucas
Démarche algorithmique
création d’une cellule de X durable d’adresse Elem
MAJ position courante (l’élément courante = adresse de la dernière cellule)
chaînage de la nouvelle cellule avec la liste (l’élément suivant du courant Elem)
Structures de Données
Dpt Info, L. Lucas
12
Elem
5
23
9
16
7
18
Tête
12
Elem
C
C
PC
Dpt Info, L. Lucas
Démarche algorithmique
création d’une cellule de X durable d’adresse Elem
chaînage de la liste avec nouvelle cellule (l’élément suivant du précédent du courant Elem)
chaînage de la nouvelle cellule avec la liste (l’élément suivant de Elem C)
Structures de Données
Dpt Info, L. Lucas
12
Elem
5
23
9
16
7
18
Tête
12
Elem
C
C
Dpt Info, L. Lucas
Démarche algorithmique
création d’une cellule de X durable d’adresse Elem
chaînage de la liste avec nouvelle cellule (l’élément suivant de C Elem)
chaînage de la nouvelle cellule avec la liste (l’élément suivant de Elem suivant de C)
Structures de Données
Dpt Info, L. Lucas
5
23
9
16
7
18
Tête
Elem
Dpt Info, L. Lucas
Démarche algorithmique
réaffectation de Tête (Tête = l’élément suivant de Tête)
destruction de la cellule durable d’adresse Elem
Structures de Données
Dpt Info, L. Lucas
5
23
9
16
7
18
Tête
C
PC
Elem
Dpt Info, L. Lucas
Démarche algorithmique
MAJ position courante et mémorisation de cette position (Elem = C = adresse de la dernière cellule)
chaînage (l’élément suivant de PC NULL)
destruction de la cellule durable d’adresse Elem
réaffectation du courant (C = PC)
Structures de Données
Dpt Info, L. Lucas
5
23
9
16
7
18
Tête
C
Elem
PC
Dpt Info, L. Lucas
Démarche algorithmique
chaînage (l’élément suivant de PC suivant de C)
destruction de la cellule durable d’adresse Elem
réaffectation du courant (C = PC)
Structures de Données
Dpt Info, L. Lucas
Raisonnement par récurrence :
L = <> résultat = n
Courant(L) val, Suivant (L)
Dpt Info, L. Lucas
Raisonnement par récurrence :
L = <>
Courant(L) val, résultat = nbocc(Suivant(L), val)
Structures de Données
Dpt Info, L. Lucas
Accès dans une liste
De façon identique à ce que nous avons décrit dans le cas de la gestion d’une table, on distingue pour les listes 2 sortes d ’accès :
l’accès par position
Dpt Info, L. Lucas
Accès par position / Schéma itératif
L ’algorithme s’arrête si il n’y a plus d’éléments à traiter
dérouter par ErrFinListe/ErrListeVide ou si i = n
Op [] (l ex LstS de X, n nouv N) res ex X
Déroutable par ErrFinListe
Structures de Données
Dpt Info, L. Lucas
Accès par position / Schéma récursif
Op [] (l ex LstS de X, n nouv N) res ex X
Déroutable par ErrFinListe
Fin Oublier l Eliminer n
elementk (l ex LstS de X, n nouv N) res ex X
Déroutable par ErrFinListe
sinon construire (res, elementk(Suivant(l),n-1))
Fin Oublier l Eliminer n
L ’algorithme s’arrête si,il n’y a plus d’éléments à traiter
dérouter par ErrFinListe/ErrListeVide ou si n = 0
Structures de Données
Dpt Info, L. Lucas
Accès associatif / Schéma itératif
Recherche (l ex LstS de X, x nouv X) res nouv B
Déroutable par ErrFinListe
construire (res, B éphémère (Vrai))
Fin Oublier l Eliminer n, i
L ’algorithme s’arrête si il n’y a plus d’éléments à traiter
dérouter par ErrFinListe/ErrListeVide ou si x l
Accès associatif = Recherche
Structures de Données
Dpt Info, L. Lucas
Interface utilisateur
Dépend de :
Variables Globales / Champs Publics :
construire(acreer ex LstD de X, l ex LstD de X)
op = (dst ex LstD de X, src ex LstD de X) res ex LstD de X
constructeur par copie et réaffecteur
(recopie des éléments)
Déroutable par ErrAllocationMémoire
détruire (adet ex LstD de X) destructeur (libère espace alloué)
p 1/2
Première approche
vision propriétaire
Dpt Info, L. Lucas
Autres fonctions :
Vide (l ex LstD de X) res nouv B Liste l vide
Premier (l ex LstD de X) res ex X Premier élément de l
Déroutable par ErrListeVide MAJ position courante
Courant (l ex LstD de X) res ex X Retourne élément
Déroutable par ErrListeVide courant
Suivant (l ex LstD de X) res ex X Elément suivant la
Déroutable par ErrFinListe position courante
MAJ position courante
Précédent (l ex LstD de X) res ex X Elément suivant la
Déroutable par ErrFinListe position courante
MAJ position courante
Ajout (l ex LstD de X, x nouv X) Ajout d ’un élément
Déroutable par ErrAllocationMémoire x par rapport à la
position courante
Déroutable par ErrListeVide l’élément courant
écrire Indisponible, utiliser la fonction écrire du type X
saisir Indisponible, utiliser la fonction saisir du type X
p 2/2
Dpt Info, L. Lucas
12
Elem
5
23
9
16
7
18
Tête
Queue
12
Tête
5
23
9
16
7
18
Queue
Dpt Info, L. Lucas
12
Elem
5
23
9
16
7
18
Tête
Queue
12
5
23
9
16
7
18
Tête
Queue
Dpt Info, L. Lucas
12
Elem
5
23
9
16
7
18
Tête
Queue
C
12
5
23
9
16
7
18
Tête
Queue
Dpt Info, L. Lucas
12
Elem
5
23
9
16
7
18
Tête
Queue
C
12
5
23
9
16
7
18
Tête
Queue
Dpt Info, L. Lucas
5
23
9
16
7
18
Tête
Queue
23
9
16
7
18
Tête
Queue
5
Elem
Dpt Info, L. Lucas
5
23
9
16
7
18
Tête
Queue
5
23
9
16
7
Tête
Queue
18
Elem
Dpt Info, L. Lucas
5
23
9
16
7
18
Tête
Queue
C
5
23
9
16
7
18
Tête
Queue
Elem
C
Dpt Info, L. Lucas
Dpt Info, L. Lucas
Dpt Info, L. Lucas
conclusion
Le principe général consiste à dissocier la gestion de la structure de données des éléments nécessaires à son parcours. Les avantages majeurs apportés par ce type d’approches reposent sur :
des parcours multiples d’une même entité,
un développement modulaire du concept sous-jacent.
Structures de Données
Dpt Info, L. Lucas
Interface utilisateur
Dépend de :
Variables Globales / Champs Publics :
construire(acreer ex LstS de X) création d’une liste vide
construire(acreer ex LstS de X, l ex LstS de X)
op = (dst ex LstS de X, src ex LstS de X) res ex LstS de X
constructeur par copie et réaffecteur
(recopie des éléments)
Déroutable par ErrAllocationMémoire
détruire (adet ex LstS de X) destruction des éléments (libère espace alloué)
p 1/2
Seconde approche
vision partagée
Dpt Info, L. Lucas
Autres fonctions :
Vide (l ex LstS de X) res nouv B Liste l vide
Vider (l ex LstS de X) Remise à zéro de l
Ajout (l ex LstS de X, x nouv X) Ajout d’un élément x
Déroutable par ErrAllocationMémoire en tête de l
Ajout (ld ex LstS de X, ls ex LstS de X) Ajout d’une liste ls
Déroutable par ErrAllocationMémoire en tête de ld
écrire Indisponible, utiliser la fonction écrire du type X
saisir Indisponible, utiliser la fonction saisir du type X
p 2/2
Dpt Info, L. Lucas
Interface utilisateur
Dépend de :
Variables Globales / Champs Publics :
construire(acreer ex LstD de X) création d’une liste vide
construire(acreer ex LstD de X, l ex LstD de X)
op = (dst ex LstD de X, src ex LstD de X) res ex LstD de X
constructeur par copie et réaffecteur
(recopie des éléments)
Déroutable par ErrAllocationMémoire
détruire (adet ex LstD de X) destruction des éléments (libère espace alloué)
p 1/2
Seconde approche
vision partagée
Dpt Info, L. Lucas
Autres fonctions :
Vide (l ex LstD de X) res nouv B Liste l vide
Vider (l ex LstD de X) Remise à zéro de l
Ajout (l ex LstD de X, x nouv X) Ajout d’un élément x
Déroutable par ErrAllocationMémoire en tête de l
Ajout (ld ex LstD de X, ls ex LstD de X) Ajout d’une liste ls
Déroutable par ErrAllocationMémoire en tête de ld
écrire Indisponible, utiliser la fonction écrire du type X
saisir Indisponible, utiliser la fonction saisir du type X
p 2/2
Dpt Info, L. Lucas
Interface utilisateur
Dépend de :
Variables Globales / Champs Publics :
Fonctions et opérateur :
construire(acreer ex ParcLstS de X, l ex LstS) création d’un « parcoureur » de liste à partir de l
construire(acreer ex ParcLstS de X, pl ex ParcLstS de X) clonage d’un « parcoureur »
op = (dst ex ParcLstS de X, src ex ParcLstS de X) res ex ParcLstS de X
réaffecteur
p 1/2
Seconde approche
vision partagée
Dpt Info, L. Lucas
Autres fonctions :
Début (l ex ParcLstS de X) res nouv B position courante au début
Fin (l ex ParcLstS de X) res nouv B position courante à la fin
AjoutPosCrt (l ex ParcLstS de X, x nouv X) Ajout d’un élément x
Déroutable par ErrAllocationMémoire en position courante
AjoutAvPrec (l ex ParcLstS de X, x nouv X) Ajout d’un élément x
Déroutable par ErrAllocationMémoire avant le précédent
AjoutApSuiv (l ex ParcLstS de X, x nouv X) Ajout d’un élément x
Déroutable par ErrAllocationMémoire après le suivant
Suppression (l ex ParcLstS de X, prec nouv B) Déroutable par ErrListeVide
AccésProchain (l ex ParcLstS de X) res ex X Déroutable par ErrFinListe
AllerDébut (l ex ParcLstS de X) Déroutable par ErrListeVide
écrire Inutile
saisir Inutile
p 2/2
Dpt Info, L. Lucas
Interface utilisateur
Dépend de :
Variables Globales / Champs Publics :
Fonctions et opérateur :
construire(acreer ex ParcLstD de X, l ex LstD) création d’un « parcoureur » de liste à partir de l
construire(acreer ex ParcLstD de X, pl ex ParcLstD de X) clonage d’un « parcoureur »
op = (dst ex ParcLstD de X, src ex ParcLstD de X) res ex ParcLstD de X
réaffecteur
p 1/2
Seconde approche
vision partagée
Dpt Info, L. Lucas
Autres fonctions :
Début (l ex ParcLstD de X) res nouv B position courante au début
Fin (l ex ParcLstD de X) res nouv B position courante à la fin
AjoutPosCrt (l ex ParcLstD de X, x nouv X) Ajout d’un élément x
Déroutable par ErrAllocationMémoire en position courante
AjoutAvPrec (l ex ParcLstD de X, x nouv X) Ajout d’un élément x
Déroutable par ErrAllocationMémoire avant le précédent
AjoutApSuiv (l ex ParcLstD de X, x nouv X) Ajout d’un élément x
Déroutable par ErrAllocationMémoire après le suivant
Suppression (l ex ParcLstD de X, prec nouv B) Déroutable par ErrListeVide
AccésProchain (l ex ParcLstD de X) res ex X Déroutable par ErrFinListe
AccésPrécédent (l ex ParcLstD de X) res ex X Déroutable par ErrFinListe
AllerDébut (l ex ParcLstD de X) Déroutable par ErrListeVide
AllerFin (l ex ParcLstD de X) Déroutable par ErrListeVide
écrire Inutile
saisir Inutile
p 2/2
Dpt Info, L. Lucas
Dpt Info, L. Lucas
Dpt Info, L. Lucas
De façon général, les traitements sur les listes (simplement comme doublement chaînées) restent identiques dans leurs approches algorithmiques. On retrouve les mêmes fonctionnalités.
La gestion d’une liste est par contre amenée à changer. Cette dernière nécessitera au minimum l’utilisation un type LstS de X auquel on pourra lui adjoindre autant de de type ParcLstS de X.
Structures de Données
Dpt Info, L. Lucas
Dpt Info, L. Lucas
La PILE implante un conteneur particulier au regard des deux précédents. Contrairement aux listes et aux tables, elle ne sert généralement pas à conserver de façon définitive des informations (contenant hautement volatile). On s’intéresse plutôt à la suite des états de la pile en utilisant le fait que le dernier élément ajouté se trouve au sommet de la pile, afin de pouvoir être atteint le premier.
Dpt Info, L. Lucas
La stratégie de gestion d’une PILE repose sur la relation « dernier arrivé, premier sorti ». En anglais on dira Last In First Out (LIFO).
Dpt Info, L. Lucas
Définition des primitives d’accés
Une pile est structure linéaire, telle que le passage d ’un état au suivant se fait par adjonction ou suppression d’un élément en tête. Une pile est généralement schématisé par une suite chronologique de ses états :
sommet
base
Dpt Info, L. Lucas
conclusion
Bien que théoriquement de taille infinie, une pile est toujours dans la pratique, formée d’un nombre fini d’éléments qui correspond à la taille maximale de la pile. Cette taille maximale est selon le type d ’implémentation explicitée ou non.
PILE
TABLE
LISTE
Taille limitée uniquement
Dpt Info, L. Lucas
Interface utilisateur
Dépend de :
Variables Globales / Champs Publics :
construire(acreer ex Pile de X, l ex Pile de X)
op = (dst ex Pile de X, src ex Pile de X) res ex Pile de X
constructeur par copie et réaffecteur
(recopie des éléments)
Déroutable par ErrAllocationMémoire
détruire (adet ex Pile de X) destructeur (libère espace alloué)
p 1/2
Dpt Info, L. Lucas
Autres fonctions :
Vide (p ex Pile de X) res nouv B Pile p vide
Empiler (p ex Pile de X, x nouv X) Empile l’élément x
Déroutable par ErrAllocationMémoire
Dépiler (p ex Pile de X) res nouv X Dépile élément en sommet de p
Déroutable par ErrPileVide
Sommet (p ex Pile de X) res ex X Retourne le sommet de p
Déroutable par ErrPileVide
Vider (p ex Pile de X) Remise à zéro de p
écrire Indisponible, utiliser la fonction écrire du type X
saisir Indisponible, utiliser la fonction saisir du type X
p 2/2
Dpt Info, L. Lucas
Dpt Info, L. Lucas
Dpt Info, L. Lucas
4
Elem
12
23
8
Tête
4
Elem
Dpt Info, L. Lucas
4
12
23
8
4
sommet
sommet
Dpt Info, L. Lucas
4
12
23
8
Tête
Elem
Dpt Info, L. Lucas
Dpt Info, L. Lucas
conclusion
Les applications utilisant des piles sont nombreuses. On peut citer à titre d’exemple :
l’évaluation de fonctions récursives,
les parcours arborescents,
...
L ’évaluation de (A+(C*D)) avec A=3, C=4 et D=5 passe par les étapes suivantes:
évaluation((A+(C*D))) = opération(+,3,(évaluation((C*D)))
= opération(+,3,opération(*,4,5))
= opération(+,3,20)
= 23
Dpt Info, L. Lucas
Dpt Info, L. Lucas
La FILE implante un conteneur dont le comportement est celui d ’une file d’attente. Les premiers individus d ’une file d’attente sont servis les premiers.
Ces files d ’attente sont d’un usage très répandu dans la programmation système, où elles servent à gérer, par exemple, l’allocation des ressources.
Une File d’attente est une structure linéaire telle que
les insertions sont toujours effectuées en fin,
les suppressions sont toujours effectuées en tête.
Dpt Info, L. Lucas
La stratégie de gestion d’une FILE repose sur la relation « premier arrivé, premier sorti ». En anglais on dira Fisrt In First Out (FIFO).
Dpt Info, L. Lucas
conclusion
La taille d’une file d’attente est, comme pour une pile, dépendante du type sous-jacent. Une vision contiguë limitera par défaut la taille de la file, alors qu’une vision chaînée ne sera limitée intrinsèquement que par la capacité mémoire de l’ordinateur.
FILE
TABLE
LISTE
Taille limitée uniquement
Dpt Info, L. Lucas
Interface utilisateur
Dépend de :
Variables Globales / Champs Publics :
construire(acreer ex File de X, l ex File de X)
op = (dst ex File de X, src ex File de X) res ex File de X
constructeur par copie et réaffecteur
(recopie des éléments)
Déroutable par ErrAllocationMémoire
détruire (adet ex File de X) destructeur (libère espace alloué)
p 1/2
Dpt Info, L. Lucas
Autres fonctions :
Vide (f ex File de X) res nouv B File f vide
Enfiler (f ex File de X, x nouv X) Enfile l’élément x
Déroutable par ErrAllocationMémoire
Défiler (f ex File de X) res nouv X Défile élément en sommet de f
Déroutable par ErrFileVide
Sommet (f ex File de X) res ex X Retourne le sommet de f
Déroutable par ErrFileVide
Vider (f ex File de X) Remise à zéro de f
écrire Indisponible, utiliser la fonction écrire du type X
saisir Indisponible, utiliser la fonction saisir du type X
p 2/2
Dpt Info, L. Lucas
Dpt Info, L. Lucas
Dpt Info, L. Lucas
4
Elem
Dpt Info, L. Lucas
4
12
23
8
4
sommet
sommet
base
base
Dpt Info, L. Lucas
4
12
23
8
Tête
Elem
Dpt Info, L. Lucas
Dpt Info, L. Lucas
Dpt Info, L. Lucas
conclusion
La représentation chaînée est plus encombrante que la représentation contiguë et l’accès à un élément est également moins rapide. Par contre, une mise à jour ne nécessitant aucune recopie, son coût est moins élevé que dans le cas d’une représentation contiguë. On choisit une représentation chaînée chaque fois que les mises à jour sont plus importantes que les consultations et une représentation contiguë chaque fois que les consultations l’emportent sur les mises à jour.
Dans la pratique, on utilise très souvent des structures mixtes composées de listes et de tables.
Structures de Données
objet «
pointé