Collections Séquence 2. Spécification algébrique - (CUI)

G. Falquet, CUI, Université de Genève 1 de 26
Collections
Conteneurs de données avec différents protocoles d’accès
Séquences
Listes binaires
Ensembles et multi-ensembles / itérateurs
Fonctions / associations
Piles / récursivité
Files / simulation, coopération
• Vue externe (opérations, définition abstraite)
• Techniques d’implémentations (performances)
G. Falquet, CUI, Université de Genève 2 de 26
Séquence
• Collection d’objets placés selon un ordre.
• Chaque objet possède une position.
• On place et enlève les éléments selon leur position.
Séquences et chaines (de caractères) ?
• même structure : <a1, a2, …, an> , {1 → a1, 2 → a2, …, n → an}
• opérations différentes
– chaines : recherche de sous-chaines, comparaison lexicale.
– séquences : recherche d’un élément
G. Falquet, CUI, Université de Genève 3 de 26
2. Spécification algébrique - opérations
Constructeurs
vide crée une séquence vide
inserer(e, i, s) insère un élément e à la position i dans s
supprimer(i, s) supprime l’élément à la position i
remplacer(e, i, s) remplace l’élément à la position i par e
Sélecteurs
element(i, s) l’élément à la position i dans s
indice(f, s) position du premier élément égal à f
indice-apres(f, d, s) position du premier élément égal à f après la position d
longueur(s) nombre d’éléments dans s
G. Falquet, CUI, Université de Genève 4 de 26
Axiomes
longueur(vide) == 0
longueur(inserer(e, i, s) == longueur(s)+1
longueur(supprimer(i, s) == longueur(s)–1;
supprimer(i, inserer(e, i, s) == s;

G. Falquet, CUI, Université de Genève 5 de 26
Axiomes - insertion/suppression/élément
j < i ⇒ element(j, inserer(e, i, s) == element(j, s)
i = j ⇒ element(j, inserer(e, i, s) == e
j > i ⇒ element(j, inserer(e, i, s) == element(j–1, s)
j < i ⇒ element(j, supprimer(i, s)) == element(j, s)
j ≥ i ⇒ element(j, supprimer(i, s)) == element(j+1, s)
G. Falquet, CUI, Université de Genève 6 de 26
Opération indice
indice(e, vide) == –1
element(0, s) = e ⇒ indice(e, s) == 0
element(0, s) ≠ e ⇒ indice(e, s) == indice(e, supprimer(0, s))+1
G. Falquet, CUI, Université de Genève 7 de 26
Utilisation des séquences
Données de taille variable (≠ Tableaux)
Données dont l’ordre est signifiant
• texte = séquence de mots
• historique = séquence d’évènements
• …
** Eviter d’utiliser les séquences quand il n’y a pas d’ordre sous-jacent (utiliser
Ensemble et Multi-ensemble)
** Les implémentations ont des performances très variées pour les diverses
opérations
G. Falquet, CUI, Université de Genève 8 de 26
Implémentation
• Tableaux extensibles (c.f. chaînes de caractères)
• Listes liées
• Itérateurs

G. Falquet, CUI, Université de Genève 9 de 26
Implémentation par tableaux extensibles
type ListeTableau = (longueur : Entier, elements : Tableau)
procedure extension (L : ListeTableau)
nt := nouveau Tableau[2 * longueur]
nt[0 .. longueur–1] := L.elements[0 .. longueur–1]
L.elements := nt;
2t opérations insérer().
On devra étendre le tableau t fois,
nombre d’éléments à copier lors des extensions : 1, 2, 4, …, 2t = (2t+1-1).
nombre moyen de recopies par opération : (2t+1-1)/2t = 2 – 1/2t.
quasiment constant = 2.
G. Falquet, CUI, Université de Genève 10 de 26
Performances
vide O(1)
inserer(e, i, s) O(n – i) , (décaler n–i éléments)
environ O(1) si on insère à la fin
supprimer(i, s) O(n – i) , (décaler n–i éléments)
environ O(1) si on supprime à la fin
remplacer(e, i, s) O(1)
element(i, s) O(1)
indice(f, s) O(n)
indice-apres(f, d, s) O(n – d)
longueur(s) O(1)
G. Falquet, CUI, Université de Genève 11 de 26
Listes liées
• ensemble de noeuds,
• contiennent chacun un élément et sont liés les uns aux autres pour former une
liste.
• un noeud ne peut appartenir qu’à une seule liste.
type Noeud = (element : T, suivant : référence Noeud)
type ListeLiee = (debut : Noeud, longueur : Entier)
debut
suivant
contenu
longueur : 4
ListeLiée Noeud Noeud
Noeud
Noeud
Noeud
suivant
suivant
suivant
suivant
G. Falquet, CUI, Université de Genève 12 de 26
Opérations
insererDebut (L, e)
nn ← nouveau Noeud()
nn.contenu ← e
nn.suivant ← premier
L .premier ← nn
L .longueur ← L.longueur+1}
supprimerDebut (L ) {
précondition: L .premier ≠ nul
L .premier ← L .premier.suivant
L .longueur ← L .longueur–1 }
element (L, i) {
n ← L . premier;
pour j de 1 à i–1 { n ← n . suivant }
retourner n . contenu
e
+1

G. Falquet, CUI, Université de Genève 13 de 26
Complexités
pour i de 1 à n
s.inserer(e, i)
Complexité quadratique !
Origine de la complexité : aller jusqu’au noeud i
vide O(1)
inserer(e, i, s) O(i)
supprimer(i, s) O(i)
remplacer(e, i, s) O(i)
element(i, s) O(i)
indice(f, s) O(n)
indice-apres(f, d, s) O(n – d)
longueur(s) O(1)
G. Falquet, CUI, Université de Genève 14 de 26
Itérateurs
• curseur se déplaçant sur la liste.
• mémoriser une position
• effectuer des opérations d’insertion ou de suppression.
Implémentation d’un itérateur sur une liste liée
type Itérateu = (liste : ListeLiee, position : Noeud)
ListeLiéée
Itérateur
début
liste
position
G. Falquet, CUI, Université de Genève 15 de 26
Opérations du type Itérateur
initialiser (I, L)
I.position ← L.premier
I.liste ← L
avancer (I)
PRE: I.position ≠ nul
I.position ← position.suivant
courant (I)
PRE: I.position ≠ nul
retourner I.position.contenu
remplacer (I, e)
I.position.contenu ← e
G. Falquet, CUI, Université de Genève 16 de 26
Opérations (suite)
insererApres (I, e )
PRE: I.position ≠ nul
nn ← nouveau Noeud()
nn.contenu ← e
nn.suivant ← I.position.suivant
I.position.suivant ← nn
supprimerApres (I)
PRE: I.position ≠ nul et I.position.suivant ≠ nul
I.position.suivant ← I.position.suivant.suivant

G. Falquet, CUI, Université de Genève 17 de 26
Exemple
Une liste s de nombres entiers, on veut multiplier par 12 chaque élément de la liste.
Méthode directe (quadratique)
pour i de 1 à s.longeur() {
x := s.element(i);
s.remplacer(12*x, i)
}
Avec un itérateur (linéaire)
iter := nouveau Itérateur;
iter.initialiser(s);
pour i de 1 à s.longueur() {
iter.remplacer(12*iter.courant());
iter.avancer()
}
G. Falquet, CUI, Université de Genève 18 de 26
Listes “binaires”
Définition récursive (polylithique)
une liste est
• soit vide
• soit composée d’un élément (tête) et d’une liste (reste)
t r
G. Falquet, CUI, Université de Genève 19 de 26
Représentation d’une séquence
a
c
d
k
g
<a, c, d, g, k> =
()
G. Falquet, CUI, Université de Genève 20 de 26
Une séquence imbriquée
Un élément est soit un atome (valeur simple), soit une liste
a
c
d
g
<a, <c, d>, g> =
()
()