Introduction aux listes. Cours numéro 5 : Les listes LI213 Types et Structures de données. Les listes simplement chaînées

Transcription

1 Introduction aux s LI Types et Structures de données Liste : définition Collection ordonnée d éléments [x ;...; x n ] (au moins) accessibles l un après l autre de x jusqu à x n. Exemple : dans la [ ; ;5 ; ;6], on peut accéder à. À partir de, on peut accéder à, et ainsi de suite. Licence d Informatique Université Paris 6 Cette définition ne présuppose rien sur la représentation en mémoire. En principe, pas de contrainte sur le nombre d éléments dans la. Les s simplement chaînées récursive : une est composée d un élément (la tête) suivi par la des éléments suivants (la queue). Illustration graphique : x x x Les seuls opérateurs : Un opérateur pour accéder à la tête : car en LISP/Scheme, hd en OCAML. Un opérateur pour accéder à la queue : cdr en LISP/Scheme, tl en OCAML. toujours faire un dessin indiquant comment sont chaînés les éléments. Vous pensez pouvoir vous en passer? OK, vous aurez des bugs, à vous de voir... Intérêt des s chaînées (/) x x x Les flèches sont des pointeurs = en mémoire, les boites ne sont pas placées les unes à côté des autres Avantages des s simplement chaînées Suppression d un élément facile et rapide : parcourir la jusqu à l élément à supprimer puis rechaîner x x x... On peut rajouter autant d éléments que l on veut Utilisation d un espace mémoire proportionnel au nombre d éléments (= pas de perte de mémoire) x n

2 Inconvénients des s chaînées (/) Les s doublement chaînées x x x Inconvénients des s simplement chaînées Temps d accès aux éléments : il faut en moyenne parcourir n/ éléments avant de trouver un élément donné. Conclusion : utilisation C est une structure à utiliser : quand effectue souvent des ajouts/suppressions d éléments, quand on ne sait pas a priori combien on aura d objets x i Similaire à une simplement chaînée sauf qu on peut aussi accéder au prédécesseur. Illustration graphique : x x x Inconvénients du double chaînage par rapport au simple chaînage : chaînage plus complexe à gérer ( pointeurs au lieu d un) utilise plus de mémoire Avantages du double chaînage par rapport au simple chaînage : suppression d un élément plus rapide : rechaîner autour de l élément à supprimer = parcours de inutile Les s circulaires Listes telles que le «dernier» élément de la a pour suivant le «premier» Illustration graphique : x x x x n circulaire simplement chaînée x x x x n circulaire doublement chaînée Utilisation : exécution de threads (fonctions s exécutant en concurrence ( en parallèle)) bilan : comparaison avec les tableaux nb d éléments arbitraire borné accès aux éléments lent (parcours) rapide tableau insertion au début rapide lente (décalages) insertion en fin lente (parcours) rapide insertion au milieu lente (parcours) lente (décalages) suppression rapide (rechaînage) lente (décalages) Règle : Utiliser plutôt des tableaux sauf si : on doit faire beaucoup de suppressions on ne connaît pas le nombre d éléments maximal a priori

3 Listes en OCAML type a list d OCAML : s simplement chaînées La Core Library [] = la vide [6 ; 7 ; ] = de entiers :: concaténation d un élément avec une : :: [ ; ;] = [ ; ; concaténation de s : [ [ ;] = [ ; ; ;] Librairie standard : le module List hd : a list -> a : renvoie la tête de la tl : a list -> a list : renvoie la queue de la Parcours d une (/) # open List ;; let rec somme = if = [] then 0 else hd + somme (tl ) ;; #trace somme ;; somme [5 ; 6 ; 7];; val somme : int list -> int = <fun> somme <-- [5 ; 6 ; 7] somme <-- [6 ; 7] somme <-- [7] somme <-- [] somme --> 0 somme --> 7 somme --> somme --> 8 - : int = 8 tester la fin de la récursion avant l appel récursif Parcours d une (/) Parcours d une s d une en OCAML type a list = [] a :: a list type somme - cf. cours 6 = possibilité de matching : [] -> = vide x :: reste -> x = tête de reste = queue de Règle : Parcourez les s en utilisant le matching plutôt que hd et tl Règle : Profitez au maximum de la puissance du matching! # let rec somme = [] -> 0 tete :: queue -> tete + somme queue ;;

4 Exemple de parcours Recherche du dernier élément d une : # let rec dernier = [ x ] -> x tete :: queue -> dernier queue [] -> failwith " vide";; Recherche de l avant-dernier élément : # let rec avant dernier = x :: y :: [] -> x tete :: queue -> avant dernier queue -> failwith "pas assez d éléments";; Parcours simultané de s # let = [ ; ; ; ] and = [5 ; 6] ;; let rec ajoute l l = match (l,l) with l,[] -> l [],l -> l tete :: queue, tete ::queue -> (tete + tete) :: ajoute queue queue ;; ajoute ;; - : int list = [6 ; 8 ; ; ] ajoute [ ; ; ; ] [5 ; 6] [6 ; 8 ; ; ] ( + 5) :: (ajoute [ ; ; ] [6]) [6 ; 8 ; ; ] ( + 6) :: (ajoute [ ; ] []) [8 ; ; ] [ ; ] [ ; ] Le filtre n importe quel motif! Rappel : identifiants dans le matching # let position elt = let rec recherche nb = elt :: reste -> nb tete :: reste -> recherche reste (nb+) [] -> failwith "élément non trouvé" in recherche 0 ;; position [ ; ; ; ] ;; val position : a list -> b -> int = <fun> - : int = 0 Retourne 0 au lieu de Rappel : les identifiants qui apparaissent dans les motifs sont non liés. Le filtrage les lie localement à des parties de la valeur filtrée. Insertion en début de # let insere debut elt = elt : : ;; let = [ ; ; ] ;; insere debut ;; val insere debut : a list -> a -> a list = <fun> val : int list = [ ; ; ] - : int list = [ ; ; ; ] insertion rapide (pas de parcours de ) ne modifie pas la mais éléments partagés avec

5 Insertion en fin de # let rec insere fin elt = tete :: queue -> tete :: insere fin queue elt [] -> [elt] ;; let = [ ; ; ] ;; insere fin ;; insertion lente : parcours de aucun élément partagé avec Insertion après un élément # let rec insere apres elt after = tete :: queue -> if tete = after then after :: elt :: queue else tete :: insere apres queue elt after [] -> [] ;; insere apres [ ; ; 5 ; 6] ;; - : int list = [ ; ; ; 5 ; 6] retournée insertion lente : parcours de fin de partagée avec 5 6 Suppression en début de # let suppression debut = tete :: queue -> queue [] -> [] ;; let = [ ; ; ; ] ;; suppression debut ;; - : int list = [ ; ; ] suppression rapide (pas de parcours) ne modifie pas la mais retourne une partagée Suppression en fin de # let rec suppression fin = [ ] -> [] tete :: queue -> tete :: suppression fin queue [] -> [] ;; suppression fin [ ; ; ; ];; - : int list = [ ; ; ] suppression lente : parcours de aucun élément partagé avec

6 Suppression après un élément # let rec suppr apres after = un :: deux :: queue -> if un = after then un :: queue else un :: suppr apres (deux :: queue) after -> ;; suppr apres [ ; ; ; 5 ; 6] ;; - : int list = [ ; ; 5 ; 6] retournée suppression lente : parcours de fin de partagée avec 5 6 Fonction iter iter : ( a -> unit) -> a list -> unit iter f [a ;... ; an] applique la fonction f à tour de rôle à a, puis a, etc. équivalent à (f a ; f a ;... ; f an ; ()) Exemple # let f x = print string ("nombre : " ˆ string of int x ˆ "\n") ;; List.iter f [ ; ; ; ];; nombre : nombre : nombre : nombre : - : unit = () Fonction map Fonction fold left map : ( a -> b) -> a list -> b list f [a ;... ;an] retourne la [f a ;... ;f an] Exemples # List.map string of int [ ; ; ; ];; - : string list = ["" ; "" ; "" ; ""] # let f x = x * x ;; List.map f [ ; ; ; ];; - : int list = [ ; ; 9 ; 6] fold left : ( a -> b -> a) -> a -> b list -> a fold left f a [b ;... ; bn] retourne la valeur de l expression f (... (f (f a b) b)...) bn Exemples # let f str nb = str ˆ " " ˆ (string of int nb) ;; List.fold left f "nombre :" [ ; ; ; ];; - : string = "nombre : " # let somme nb nb = nb + nb ;; List.fold left somme 0 [ ; ; ; ] ;; List.fold left (+) 0 [ ; ; ; ];; 0 0

7 Fonction fold right fold right : ( a -> b -> b) -> a list -> b -> b fold right f [a ;... ; an] b retourne la valeur de l expression f a (f a (... (f an b)...)) Exemple # let f nb str = str ˆ " " ˆ (string of int nb) ;; List.fold right f [ ; ; ; ] "nombre :";; - : string = "nombre : "