Les listes. Chapitre Les listes en Caml Propriétés de base des listes de Caml

Transcription

1 Chapitre 6 Les listes La structure de liste est l'une des plus fondamentale en programmation. 6.1 Les listes en Caml La structure de liste est dénie dans le langage Caml de base 1. Une première façon de construire une liste est d'en écrire explicitement l'énumération de ses éléments. Exemple 1 : En voici quelques exemples : # [3 ; 2 ; 1 ; 3] ;; - : int list = [3; 2; 1; 3] # [true ; false ; false ] ;; - : bool list = [true; false; false] # [ a ; b ] ;; - : char list = [ a ; b ] # [( a, 1) ; ( b, 2)] ;; - : (char * int) list = [( a, 1); ( b, 2)] # [[2.5 ; -1.3] ; [0.] ; [sqrt(2.) ; sin(1.)]] ;; - : float list list = [[2.5; -1.3]; [0.]; [ ; ]] Tirons quelques enseignements de ces exemples Propriétés de base des listes de Caml Les listes peuvent être de longueur quelconque Tout d'abord les listes peuvent contenir n'importe quel nombre d'éléments. Les exemples qui précèdent montrent dans l'ordre une liste de quatre éléments, une liste de trois éléments, une liste de deux éléments, encore une liste de deux éléments, et enn une liste de trois éléments. Une liste peut aussi être vide. 1. c'estàdire dans le module Pervasives 1

2 2 CHAPITRE 6. LES LISTES # [] ;; - : a list = [] Le nombre d'éléments que contient une liste est appelé longueur de la liste. Le module List de la bibliothèque standard d'objective Caml déclare une fonction length qui renvoie la longueur de la liste passée en paramètre. Les listes sont typées Comme dans d'autres langages de programmation, mais aussi contrairement à d'autres langages (comme Lisp par exemple), les éléments d'une liste en Caml se doivent d'être tous du même type. Les listes de l'exemple 1 sont dans l'ordre 1. une liste d'entiers : int list ; 2. une liste de booléens : bool list ; 3. une liste de caractères : char list ; 4. une liste de couples : (char int) list ; 5. et une liste de listes d'entiers : int list list. Le type générique d'une liste est a list, où a désigne le type des éléments de la liste. Si la liste est vide, ce type a n'est pas instancié. La liste vide est polymorphe. Il n'est pas possible de construire une liste contenant des éléments de types diérents. # [1 ; true] ;; Error: This expression has type bool but an expression was expected of type int Les listes ressemblent aux tableaux mais... En Caml, il existe peu de diérences syntaxiques entre la déclaration explicite d'une liste et celle d'un tableau. Exemple 2 : # let l = [1; 4; 1; 5] and t = [ 1; 4; 1; 5 ];; val l : int list = [1; 4; 1; 5] val t : int array = [ 1; 4; 1; 5 ] # List.length l;; - : int = 4 # Array.length t ;; - : int = 4 Dans cet exemple, l est une liste de 4 entiers (int list) dénie par énumération de ses éléments entre de simples crochets [... ], tandis que t est un tableau de 4 entiers (int list) lui aussi déni par énumération de ses éléments mais entre [... ].

3 6.1. LES LISTES EN CAML 3... elles ne sont pas des tableaux Les listes se distinguent des tableaux essentiellement sur trois points 1. Il n'y a pas d'accès direct aux éléments d'une liste avec une notation indicielle comme pour les tableaux. 2. Il n'est pas possible de modier la valeur d'un élément d'une liste sans reconstruire tout ou partie de la liste. En Caml, les listes ne sont pas des structures de données mutables contrairement aux tableaux et aux chaînes de caractères. 3. Comme on le verra par la suite, il est peu coûteux de construire une liste en ajoutant un élément à une liste existante, tandis que la même opération avec les tableaux nécessite une recopie du tableau existant. Listes Tableaux Type a list a array Construction par [x 1 ; x 2 ;... ; x n ] [ x 1 ; x 2 ;... ; x n ] énumération Structure vide [] [ ] Accès direct aux éléments Non Oui Structure dynamique Oui Non Structure mutable Non Oui Table 6.1 Comparaison listes / tableaux Le constructeur :: Si le seul moyen de construire une liste était l'énumération explicite de tous ses éléments, il serait fastidieux de construire de grandes listes, mais il serait aussi et surtout impossible de les obtenir par programme. Le constructeur permettant de construire des listes par programme est noté :: (double deux points). x :: l Syntaxe : Constructeur de listes avec x de type a et l de type a list. On l'utilise comme un opérateur dont l'opérande droit (l) est une liste, et l'opérande gauche (x) est une expression du même type que les éléments de la liste. Cette construction construit une nouvelle liste dont le premier élément, ou élément de tête, est x, et dont les autres éléments, le reste, sont ceux de la liste l. Exemple 3 : 3. Voici comment construire une liste l2 obtenue en ajoutant 3 en tête de la liste l de l'exemple # let l2 = 3 :: l ;; val l2 : int list = [3; 1; 4; 1; 5] À titre de comparaison, voici comment faire l'opération analogue avec des tableaux.

4 4 CHAPITRE 6. LES LISTES # let t2 = let n = Array.length t in let t = Array.make (n + 1) 3 in for i = 1 to n do t.(i) <- t.(i - 1) done ; t ;; val t2 : int array = [ 3; 1; 4; 1; 5 ] Ce constructeur, accompagné de la constante liste vide, permet de construire n'importe quelle liste. Exemple 4 : La liste [3; 2; 1; 3] peut être obtenue en ajoutant 3 en tête de la liste [2; 1; 3]. # 3 :: [2; 1; 3] ;; - : int list = [3; 2; 1; 3] Mais la liste [2; 1; 3] peut elle aussi être obtenue par le même procédé. # 3 :: (2 :: [1; 3]) ;; - : int list = [3; 2; 1; 3] Notons qu'on peut se dispenser des parenthèses. # 3 :: 2 :: [1; 3] ;; - : int list = [3; 2; 1; 3] Évidemment on peut poursuivre avec la liste [1; 3], # 3 :: 2 :: 1 :: [3] ;; - : int list = [3; 2; 1; 3] et la liste [3]. # 3 :: 2 :: 1 :: 3 :: [] ;; - : int list = [3; 2; 1; 3] La liste vide ne peut pas être obtenue à l'aide du constructeur ::. Le procédé s'arrête là. Toute liste non vide [x 1 ; x 2 ;... ; x n ] peut être construite à partir de la liste vide et du constructeur ::. [x 1 ; x 2 ;... ; x n ] = x 1 :: x 2 ::... :: x n :: []. Il est parfois nécessaire de parenthéser les expressions intervenant dans la construction d'une liste. Dans les bons cas, l'oubli du parenthésage peut provoquer des erreurs. # 1 :: [] :: [] ;; Error: This expression has type a list but an expression was expected of type int # (1 :: []) :: [] ;; - : int list list = [[1]] Pire, l'oubli peut donner des résultats complètement diérents.

5 6.1. LES LISTES EN CAML 5 # a, 1 :: [] ;; - : char * int list = ( a,[1]) # ( a, 1) :: [] ;; - : (char * int) list = [( a, 1)] Filtrage de motifs de listes Le principal, si ce n'est le seul, moyen d'accéder aux éléments d'une liste est le ltrage de motifs. Le constructeur :: est autorisé dans les motifs utilisés pour ltrer une expression. Exemple 5 : Voici comment obtenir l'élément en tête d'une liste non vide. # match [3; 1; 4] with x :: _ -> x ;; Warning P: this pattern-matching is not exhaustive. Here is an example of a value that is not matched: [] - : int = 3 Le motif est x :: _ qui ltre toutes les listes ayant au moins un élément (les listes non vides). Le motif x ltre l'élément de tête, élément qui est celui souhaité et renvoyé (-> x). Le motif universel _ est utilisé pour ltrer le reste de la liste qui ne nous intéresse pas. L'avertissement ( Warning) donné par l'interpréteur signale la non exhaustivité du ltrage, puisque seules les listes non vides sont ltrées. Pour éviter cet avertissement, il est nécessaire de rendre complet le ltrage en introduisant une clause concernant la liste vide pour laquelle notre expression déclenche une exception. # match [3; 1; 4] with x :: _ -> x _ -> failwith "liste vide!" ;; - : int = 3 # match [3; 1; 4] with x :: _ -> x _ -> failwith "liste vide!" ;; Exception: Failure "liste vide!". De la même façon on peut obtenir le reste d'une liste. # match [3; 1; 4] with _ :: l -> l ;; _ -> failwith "liste vide!" ;; - : int list = [1; 4] On peut à partir de cette exemple, dénir deux fonctions l'une qui donne la tête d'une liste et l'autre le reste. Dans le cas où la liste est vide, ces fonctions ne sont pas dénies et déclenchent une exception. let tete l = match l with x :: _ -> x

6 6 CHAPITRE 6. LES LISTES _ -> failwith "tete : liste vide" let reste l = match l with _ :: l -> l _ -> failwith "reste : liste vide" Deux fonctions du module List donnent aussi la tête et le reste d'une liste. Ce sont respectivement les fonctions hd (pour head) et tl (pour tail). Si maintenant on souhaite le second élément d'une liste qui en contient au moins deux, nous avons deux possibilités : 1. soit par ltrage de motifs, # match [3; 1; 4] with _ :: x :: _ -> x _ -> failwith "liste vide!" ;; - : int = 1 2. soit en utilisant les deux fonctions tete et reste. # tete (reste [3; 1; 4]) ;; - : int = Le module List Le module List de la bibliothèque standard d'objective Caml dénit un certain nombre de fonctions sur les listes. Le tableau 6.2 en cite quelques unes. Fonction CU Rôle hd : a list -> a liste non vide renvoie la tête (head) de la liste. tl : a list -> a list liste non vide renvoie le reste (tail) de la liste. length : a list -> int aucune renvoie la longueur de la liste. map : ( a -> b) -> a list -> b list aucune renvoie une liste contenant les images des éléments. Table 6.2 Quelques fonctions du module List 6.2 La structure de données liste Dénition récursive de la structure de liste Dénition 1 Une liste est une suite nie éventuellement vide d'éléments. Dénition 2 Une liste est soit la liste vide () ; soit un couple (x, l) où

7 6.2. LA STRUCTURE DE DONNÉES LISTE 7 x est le premier élément de la liste qu'on appelle la tête, et l est une liste contenant les éléments qui suivent x, liste qu'on appelle reste. Cette dénition est récursive, puisque les listes non vides sont dénies par construction d'un couple dont la deuxième composante est elle-même une liste. En notant Liste(E) l'ensemble de toutes les listes dont les éléments appartiennent à un ensemble E xé, Liste(E) est le plus petit ensemble contenant la liste vide () et stable par la création de couples (x, l), avec x E et l Liste(E). Autrement dit, Liste(E) est le plus petit ensemble X, au sens de l'inclusion, vériant l'équation X = {()} (E X) Les opérations primitives Les deux constructeurs Toute liste peut être construite à partir de deux constructeurs seulement : la liste vide qui est une constante, et une opération d'ajout d'un élément en tête d'une liste, opération que nous nommerons ajoute_en_tete et dénirons comme étant la fonction ajoute_en_tete : E Liste(E) Liste(E) x, l (x, l). Les deux sélecteurs L'accès à n'importe quel élément d'une liste peut être obtenu avec deux sélecteurs seulement : une opération donnant la tête d'une liste non vide, que nous nommerons tete et dénirons comme la fonction tete : Liste(E) E (x, l)) x. CU : liste non vide et une opération donnant le reste d'une liste non vide, que nous nommerons reste et dénirons comme la fonction reste : Liste(E) E (x, l)) l CU : liste non vide. Lien entre les opérations primitives Pour tout élément x E et toute liste l Liste(E), on a tete(ajoute_en_tete(x, l)) = x reste(ajoute_en_tete(x, l)) = l, et pour toute liste non vide l Liste(E) on a ajoute_en_tete(tete(l), reste(l)) = l.

8 8 CHAPITRE 6. LES LISTES Interface d'un module Liste Bien qu'il soit inutile de le faire puisque les listes sont prédénies en Caml, nous allons construire un module Liste pour dénir un type a liste avec les opérations primitives qui l'accompagnent. En voici la partie interface (chier liste.mli). type a liste exception Liste_vide val liste_vide : a liste val ajoute_en_tete : a -> a liste -> a liste val tete : a liste -> a val reste : a liste -> a liste val est_vide : a liste -> bool Une implémentation triviale de ce module consiste à poser type a liste = a list les constructeurs et sélecteurs s'en déduisant immédiatement. La section qui suit montre une autre implémentation possible. 6.3 Une implémentation Il serait probablement possible de donner une réalisation du type liste à l'aide d'un tableau comme nous l'avons fait pour les piles et les les. Mais ce n'est pas de cette façon qu'en général les liste sont implémentées. Comme on l'a vu dans la section précédente, la structure de données abstraite liste a une dénition récursive. Idéalement, toute réalisation concrète du type liste doit donc reéter ce caractère récursif. Le langage Caml permet de le faire aisément Réalisation du type Une liste étant soit la liste vide, soit un couple (a, l) où a est l'élément de tête de la liste, et l le reste, il est naturel de réaliser le type liste par un type somme à deux constructeurs : 1. Vide pour la liste vide, ce constructeur étant constant, 2. et Cons 2 pour les listes non vides, ce constructeur s'appliquant à un couple. Ainsi on peut déclarer le type type a liste = Vide Cons of a * a liste 2. Le choix de ce nom vient de son usage courant pour les listes. C'est en particulier ce nom qui est choisi dans des langages comme Lisp ou Scheme.

9 6.4. ALGORITHMES SUR LES LISTES 9 Cette déclaration de type est récursive puisque le type a liste se dénit à l'aide de luimême. C'est une possibilité oerte par le langage que nous retrouverons pour dénir les arbres binaires (cf chapitre??) Réalisation des opérations primitives La liste vide est tout simplement la valeur Vide. let liste_vide = Vide L'ajout en tête d'un élément à une liste, s'obtient avec le constructeur Cons. let ajoute_en_tete a l = Cons (a,l) On obtient la tête d'une liste par simple ltrage de motif, ainsi que le reste. let tete l = match l with Vide -> raise Liste_vide Cons (a,_) -> a let reste l = match l with Vide -> raise Liste_vide Cons (_,l) -> l Enn, le prédicat pour tester la vacuité d'une liste est réalisé par comparaison de la liste à la liste vide. let est_vide l = l = Vide 6.4 Algorithmes sur les listes La structure récursive des listes amène très souvent une formulation récursive des algorithmes de traitement des listes Algorithmes de parcours de listes Longueur d'une liste let rec longueur l = match l with _::l -> 1 + longueur l _ -> 0 Cette fonction n'est pas récursive terminale. On peut assez facilement en donner une version récursive terminale (cf exercices).

10 10 CHAPITRE 6. LES LISTES Accès à un élément d'une liste let n_ieme l n = match l with x::l -> if n = O then x else n_ieme l (n - 1) _ -> raise Liste_vide Algorithmes de constructions de listes Construction de listes d'entiers consécutifs let rec genere_liste_decroissante n = if n = 0 then [] else n :: (genere_liste_decroissante (n - 1)) let genere_liste_croissante n = let rec aux k acc = if k = 0 then acc else aux (k - 1) (k :: acc) in aux n [] 6.5 Trier une liste Comme pour les tableaux, trier une liste c'est construire une liste contenant les mêmes éléments que la liste à trier, mais rangés dans un ordre voulu. Par exemple, trier la liste d'entiers [3; 1; 4; 1; 5] dans l'ordre croissant, c'est construire la liste [1; 1; 3; 4; 5]. Comme pour les tableaux, le module List ore une fonction de tri des listes. C'est la fonction sort (comme pour les tableaux). Cependant il existe une diérence entre la fonction de tri d'un tableau et celle pour une liste. Diérence que déjà mentionne le type de chacune de ces deux fonctions. Voici ce que donne la documentation du module Array pour la fonction sort de tri d'un tableau : val sort : ( a -> a -> int) -> a array -> unit et celle du module List pour la fonction de même nom pour trier une liste : val sort : ( a -> a -> int) -> a list -> a list Les deux fonctions prennent toutes deux deux arguments : la fonction de comparaison en premier ;

11 6.5. TRIER UNE LISTE 11 la structure de donnée à trier en second. Mais la fonction de tri d'un tableau renvoie la seule valeur de type unit, tandis que celle d'une liste renvoie une liste. Cette distinction provient des caractères mutable d'un tableau et non mutable d'une liste. Quand on trie un tableau, on peut déplacer les éléments du tableau pour les ranger ailleurs dans le même tableau par des instructions du type t.(i) <- t.(j). La fonction Array.sort opère de cette façon ce qui fait que le tableau après le tri n'est plus le même que le tableau avant le tri. # let t = [ 3; 1; 4; 1; 5 ] ;; val t : int array = [ 3; 1; 4; 1; 5 ] # Array.sort compare t ;; - : unit = () # t ;; - : int array = [ 1; 1; 3; 4; 5 ] Le tri d'un tableau se fait à l'intérieur du tableau, et modie le tableau passé en paramètre. Tandis que le tri d'une liste construit une nouvelle liste sans modier la liste passée en paramètre. # let l = [3; 1; 4; 1; 5] ;; val l : int list = [3; 1; 4; 1; 5] # List.sort compare l ;; - : int list = [1; 1; 3; 4; 5] # l ;; - : int list = [3; 1; 4; 1; 5] Tri par insertion Algorithme 6.1 Tri par insertion d'une liste Entrée : l une liste à trier Sortie : l une liste triée contenant les mêmes éléments que l. 1: si l est vide alors 2: renvoyer la liste vide 3: sinon 4: trier (par insertion) le reste de l pour obtenir une liste triée l 5: renvoyer la liste obtenue en insérant l'élément de tête de l dans l 6: n si Tri par fusion

12 12 CHAPITRE 6. LES LISTES Algorithme 6.2 Insertion d'un élément dans une liste triée Entrée : l une liste triée, et x un élément à insérer Sortie : l une liste triée contenant x et tous les éléments de l si l est vide alors renvoyer la liste (x) sinon soit y = tete(l) et l = reste(l) si x y alors renvoyer ajoute_en_tete(x, l) sinon soit l 1 la liste obtenue en insérant x dans l renvoyer ajoute_en_tete(y, l 1 ) n si n si Algorithme 6.3 Tri par fusion d'une liste Entrée : l une liste à trier Sortie : l une liste triée contenant les mêmes éléments que l. 1: si l est vide ou n'a qu'un seul élément alors 2: renvoyer l 3: sinon 4: séparer l en deux listes l 1 et l 2 de même longueur à un élément près 5: trier (par fusion) chacune des des deux listes l 1 et l 2 pour obtenir deux listes l 1 et l 2 6: fusionner les deux listes l 1 et l 2 en une liste l 7: renvoyer l 8: n si Algorithme 6.4 Séparation d'une liste en deux listes de même longueur Entrée : l une liste Sortie : (l 1, l 2 ) un couple de listes de même longueur à 1 élément près, dont les éléments sont ceux de l 1: si l est vide alors 2: renvoyer ((), ()) 3: sinon si l n'a qu'un seul élément x alors 4: renvoyer ((x), ()) 5: sinon 6: soit x et y les deux éléments en tête de l et l la liste des éléments qui suivent 7: soit (l 1, l 2 ) le couple de listes obtenu en séparant l 8: renvoyer (ajoute_en_tete(x, l 1 ), ajoute_en_tete(y, l 2 )) 9: n si

13 6.5. TRIER UNE LISTE 13 Algorithme 6.5 Fusion de deux listes triées Entrée : l 1 et l 2 deux listes triées Sortie : l une liste triée contenant tous les éléments de l 1 et l 2 1: si l 1 est vide alors 2: renvoyer l 2 3: sinon si l 2 est vide alors 4: renvoyer l 1 5: sinon 6: soit x 1 = tete(l 1 ) et l 1 = reste(l 1 ) 7: soit x 2 = tete(l 2 ) et l 2 = reste(l 2 ) 8: si x 1 x 2 alors 9: soit l la liste obtenue en fusionnant l 1 et l 2 10: renvoyer ajoute_en_tete(x 1, l ) 11: sinon 12: soit l la liste obtenue en fusionnant l 1 et l 2 13: renvoyer ajoute_en_tete(x 2, l ) 14: n si 15: n si