6 Diviser pour régner

Version

préliminaire

6.1 Le tri fusion

6.1.1 Partage de listes 6.1.1.1 Code

(∗ s p l i t : ’ a l i s t −> ’ a l i s t ∗ ’ a l i s t

( s p l i t l ) partage l a l i s t e l en deux l i s t e s de mêmes longueur : s i l e s t de longueur n , ( s p l i t l ) re tou rn e un couple ( l1 , l 2 ) t e l que l1@l2 a l e s mêmes é l é ments que l , avec même m u l t i p l i c i t é et

l 1 et l 2 sont de longueurs r e s p e c t i v e s n ’ et n ’ ’ où n ’ vaut n /2 , a r r o n d i par exc è s et n ’ ’ vaut n /2 , a r r o n d i par dé f a u t .

∗)

let rec split l = match l with

| [] -> [], []

| x::r -> let l1, l2 = split r in x::l2, l1

;;

6.1.1.2 Correction

On peut montrer que pour toute liste l de longueur n, l’appel split l termine en effectuantn appels récursifs supplémentaires par récurrence surn. On montre en même temps que cet appel retourne deux listes l1 etl2 de longueurs respectives �n�et�n�.

6.1.1.3 Complexité

De plus, à chaque appel desplit, on effectue uniquement un nombre borné d’opéra- tions qui sont toutes de temps constant, sauf l’éventuel appel récursif. On en déduit que l’exécution de split lprend un temps n+ 1×O(n) =O(n).

6.1.2 Fusion de listes triées 6.1.2.1 Code

(∗ merge : ’ a l i s t −> ’ a l i s t ∗ ’ a l i s t

( merge l 1 l 2 ) re to urn e une l i s t e contenant l e s mêmes é l é ments que l , avec même m u l t i p l i c i t é .

De plus , s i l 1 et l 2 sont des l i s t e s t r i é es par ordre c r o i s s a n t ,

Version

préliminaire

a l o r s ( merge l 1 l 2 ) e s t une l i s t e t r i é e .

∗)

let rec merge l1 l2 = match l1, l2 with

| [], l -> l

| l, [] -> l

| x1::r1, x2::r2 -> if x1 <= x2 then x1 :: merge r1 l2 else x2 :: merge l1 r2

;;

6.1.2.2 Correction

Montrons que pour toutes listes l₁ et l₂ triées par ordre croissant, l’appel fusion l₁ l₂ termine et retourne une liste l triée par ordre croissant dont les éléments sont les mêmes que ceux del₁@l₂ (avec même multiplicité).

Pour cela, notons pour n∈ N, P(n) l’assertion «pour toutes listes l₁ et l₂ triées par ordre croissant dont la somme des longueurs vautn, la fonction fusion l₁ l₂ termine et retourne une listeltriée par ordre croissant dont les éléments sont les mêmes que ceux del».

— MontronsP(0). Deux listes dont la somme des longueurs vaut0sont nécessairement vides. Orfusion [] []retourne[]qui possède les mêmes éléments que[]@[]

et qui est triée. On a doncP(0).

— Montrons queP est héréditaire. Pour cela, considérons n∈Nquelconque vérifiant P(n) et montrons P(n+ 1). Considérons donc deux listes l₁ et l₂ triées par ordre croissant dont la somme des longueurs vaut n+ 1. On peut alors distinguer trois cas :

— Si l₁ est vide, fusion l₁ l₂ retourne l₂, qui est triée par ordre croissant et possède les mêmes éléments quel1@l2.

— Si l₂ est vide, on a le même résultat.

— Si ni l₁, ni l₂ ne sont vides. Alors, il y a deux sous-cas :

— Si x1 ≤ x2, alors fusion l1 l2 retourne le résultat de l’évaluation de x1

:: fusion r₁ l₂. Orr₁ etl₂ sont triées et la somme des longueurs de r₁ etl₂ vautn. CommeP(n) est vrai,fusion r₁ l₂ retourne une liste ltriée ayant les mêmes éléments que r1@l2.x1 :: fusion r1 l2 retourne donc une liste ayant les mêmes éléments quex₁::r₁@l₂, donc que l₁@l₂. De plus, l₁ et l₂ sont triées donc x₁ minore tous les éléments de r₁ et x₂ tous ceux de l2. Comme de plus x1 ≤x2,x1 minore tous les éléments de r1@l2, donc de l, qui est triée. Donc 1x::l est triée. L’appel fusion l₁ l₂ termine et retourne une liste triée contenant les mêmes éléments que l₁@l₂.

— Si x1 > x2, on montre de même que l’appel fusion l1 l2 termine et re- tourne une liste triée contenant les mêmes éléments que l₁@l₂.

P est donc héréditaire.

On en déduit queP(n) est vrai pour tout entier n.

Soitl₁ etl₂ deux listes triées. Notonsn la somme de leur longueur. On déduit du fait qu’on aP(n), que l’appelfusion l1 l2 termine et retourne une liste triée contenant les

Version

préliminaire

mêmes éléments quel1@l2.

6.1.2.3 Complexité

On peut noter qu’à chaque appel defusion, on effectue uniquement un nombre borné d’opérations, qui sont toutes de temps constant, sauf l’appel récursif. On en déduit que la complexité temporelle de l’exécution defusion l₁ l₂ est unO(n)oùnest la somme des longueurs del₁ etl₂.

6.1.3 Tri fusion 6.1.3.1 Code

(∗ t r i _ f u s i o n : ’ a l i s t −> ’ a l i s t

( t r i _ f u s i o n l ) t r i e l a l i s t e l par ord re c r o i s s a n t , i . e . re tou rn e une l i s t e t r i é e par ordre c r o i s s a n t ayant l e s mêmes é l é ments que l , avec même m u l t i p l i c i t é .

∗)

let rec tri_fusion l = match l with

| [] -> []

| [_] -> l

| _ -> let l1, l2 = split l in merge (tri_fusion l1) (tri_fusion l2)

;;

6.1.3.2 Correction

Par l’absurde, supposons que le code detri fusionne respecte pas sa spécification, c’est-à-dire qu’il existe au moins une liste l telle que tri fusion l ne termine pas ou ne retourne pas une liste triée par ordre croissant ayant les mêmes éléments que l et choisissons lde longueur minimale.

On a alors trois cas :

— l est vide et tri fusion l retourne [] qui est une liste triée ayant les mêmes éléments que l. C’est absurde.

— lcontient un unique élément, et tri fusion l retournel qui est triée et possède les mêmes éléments qu’elle-même. C’est absurde.

— l contient au moins deux éléments. Notons n sa longueur. Alors notons l₁ et l₂ les listes retournées par l’évaluation de split l. l₁ et l₂ sont respectivement de longueurs�n/2�et�n/2�. Commen≥2,n−�n/2�=�n/2� ≥1, doncn >�n/2� ≥

�n/2�.l₁ etl₂ sont donc de longueurs strictement inférieures à celle de l. Comme l est un contre-exemple de longueur minimale à la spécification de tri fusion, tri fusion li, pouri= 1,2, retourne donc une listel^�_itriée ayant même éléments quel_i. Ortri fusion lretourne une liste qui est obtenue par fusion de l^�₁ etl^�₂. Cette liste possède donc les mêmes éléments que l^�₁@l^�₂, donc quel₁@l₂, et de plus elle est triée, ce qui est absurde.

Version

préliminaire

Donc dans tous les cas, on obtient une absurdité.

On en déduit que le code detri fusion respecte sa spécification : pour toute liste l,tri fusion ltermine et retourne une liste triée par ordre croissant ayant les mêmes éléments quel.

6.1.3.3 Complexité

6.1.3.3.1 Équation à résoudre Notons, pour n ∈ N, C_{T F}(n) le temps de calcul mis dans le cas le pire partri fusion l pour une listel de longueur n.

Les opérations effectuées par tri fusionsur une liste l de longueurn≥2 sont un filtrage (en temps constant), un appel à split l en temps O(n), un appel à fusion sur deux listesl^�₁ etl^�₂ de longueurs respectives�n/2�et�n/2�, ce qui demande un temps O(�n/2� +�n/2�) = O(n), et deux appels récursifs à tri fusion sur des listes de longueurs �n/2� et �n/2�, dont les temps de calcul sont donc au plus respectivement C_{T F}(�n/2�) etC_{T F}(�n/2�).

Le temps de calcul detri fusion lest donc au plusO(n)+O(1)+O(n)+CT F(�n/2�)+

C_{T F}(�n/2�).

Cette inégalité étant vérifiée pour toute liste de longueur l, le temps de calcul de tri fusionsur une liste de longueur ndans le cas le pire vérifie :

CT F(n)≤C��n 2

��

+C��n 2

��

+O(n)

6.1.3.3.2 Résolution Ou bien on suppose queC_{T F} est croissante, ou bien on introduit plutôt C_{T F}^� (n), le temps de calcul detri fusion dans le cas le pire pour une liste de longueurau plus n.

On a, pour toutn∈N,C_{T F}(n)≤C_{T F}^� (n)≤C_{T F}^� (n+ 1)(pour toute liste de longueur n,tri fusionmet un temps au plus égal àC_{T F}^� (n)et pour toute liste de longueur au plusn,tri fusionmet un temps au plusC_{T F}^� (n+ 1)).

DoncC_{T F}^� majore CT F et est croissante.

De plus, on a :

C_{T F}^� (n)≤C^���n 2

��+C^���n 2

��+O(n)

Il suffit de reprendre la démonstration précédente pour se convaincre que c’est le cas.¹ On peut maintenant essayer de calculerC_{T F}^� pour des valeurs particulières. Pourk∈N, posonsu_k=C_{T F}^� (2^k).

Alors, à partir d’un certain rangu_k≤2u_k−1+C2^k où C est une constante.

Une solution particulière de l’équation homogène ∀k ∈ N u_k = 2u_k−1 est la suite

�2^k�

k∈N. Posons doncλ_k=u_k2^−k pour k∈N.

1. Une autre possibilité est de remarquer que pour tout n ∈ N, C_{T F}^� (n) = max_i∈[[0,n]](CT F(i)) et d’effectuer un travail (pénible) sur les inégalités.

Version

préliminaire

On a alors :

λ_k2^k≤2^kλ_k−1+C2^k APCR

λ_k≤λ_k−1+C APCR

λ_k−λ_k−1 ≤C APCRk₀

λ_k−λ_k0 ≤(k−k₀)C pourk≥k₀ λ_k≤(k−k0)C+λ_k0 pourk≥k0

λ_k=O(k) u_k=O(k2^k)

Or pour toutn, on an≤2^�log2n� etC_{T F}^� est croissante. Donc, on a : CT F(n)≤C_{T F}^� (n)≤C_{T F}^� �

2^�log2n��

=u_�log2n�=O�

�log₂n�2^�log2n�� Or O�

�log₂n�2^�log2n��

=O(nlog₂n)etC_{T F}(n)≥0. Donc,finalement :

C_{T F}(n) =O(nlogn)

6.1.4 Conclusion sur le tri fusion

Le tri fusion est un exemple ultra-classique du paradigme «diviser pour régner». Il est moins naturel que le tri par insertion que nous avons étudié précédemment, et est donc un peu plus délicat à programmer. Cette difficulté supplémentaire valait-elle le coup ?

Le tri par insertion possède une complexité temporelle en O(n²) pour une liste de longueur n. Le tri fusion possède quant à lui une complexité O(nlogn). On peut donc dire qu’on a gagné un facteurn/lognmais ce n’est pas très parlant.

Essayons de quantifier ce gain en regardant le temps de calcul de programmes qui de- manderaient respectivementn,nlog₂n,n²,2ⁿetn!instructions pour un même problème de taillen, en supposant que le temps de calcul d’une instruction est d’une nano-seconde.

Le tableau 6.1 donne ces temps de calcul pour différentes valeurs den. On voit que les complexités linéarithmique (O(nlogn)) et quadratique (O(n²)) diffèrent vite.

6.2 Tri par pivot

6.2.1 Généralités

Ce tri est aussi appelé tri rapide (ou quicksort).

Remarque 6.1. Ce nom risque de vous induire en erreur : si le tri par pivot est effecti- vement très rapide en pratique dans les meilleurs cas, il est en pratique délicat à mettre en œuvre si on ne veut pas se trouver dans le pire des cas, où il se comporte plutôt mal.

Version

préliminaire

n nns nlog₂nns n² ns 2ⁿns n! ns

10 10 ns 30 ns 10²ns 1µs 3 ms

20 20 ns 90 ns 4×10²ns 1×10¹ms 8×10¹ans 30 30 ns 10²ns 9×10²ns 1 s 8×10¹⁵ans 40 40 ns 2×10²ns 2µs 2×10¹min

50 50 ns 3×10²ns 3µs 10 jours

60 60 ns 4×10²ns 4µs 40 ans

70 70 ns 4×10²ns 5µs 4×10⁴ans 80 80 ns 5×10²ns 6µs 4×10⁷ans 90 90 ns 6×10²ns 8µs 4×10¹⁰ans 10² 10²ns 7×10²ns 10µs

10³ 1µs 10µs 1 ms

10⁴ 10µs 1.3×10²µs 100 ms

10⁵ 10²µs 1.7 ms 10 s

10⁶ 1 ms 2.0×10¹ms 1.7×10¹min 10⁷ 10 ms 2.3×10²ms 28 h 10⁸ 100 ms 2.7 s 1×10²jours 10⁹ 1 s 3×10¹s 3×10¹ans

Table6.1 – Temps d’exécution pour quelques complexités classiques

Le tri par pivot consiste, lorsque la liste�à trier est assez grande, à effectuer les étapes suivantes :

1. On choisit dans� un élément quelconque v, qui sera appelé pivot, et on construit les listes u₁ etu₂ des autres éléments de � contenant respectivement les éléments inférieurs ou égaux xet ceux strictement supérieurs à x.

2. On trie récursivement u₁ et u₂, ce qui donne deux listes triées, appelées respecti- vement v₁ etv₂.

3. Il ne reste plus alors qu’à renvoyer^{v1 @ (x :: v2)}.

6.2.2 Code tri pivot Exercice 6.2

On rappelle qu’il existe une fonction filter : (α list → bool) → α list → α list dans le moduleList : filter p l retourne la sous-liste des éléments x de l tels que p x soit le booléen true.

Quelle est sa complexité temporelle et spatiale ?

Version

préliminaire

6.2.2.1 Fonction de partionnement d’une liste On introduit la fonction suivante :

partition : α × α list → α list ×α list

partition x l retourne deux listesu etvtelles queu@v etl possèdent les mêmes éléments (avec la même multiplicité) et tous les éléments deu sont inférieurs ou égaux àx et tous les éléménts de v sont strictement supérieurs àx

let partition x l =

letu = filter (funy → y ≤ x) l in letv = filter (funy → y > x) l in (u, v)

Exercice 6.3

Quelle est la complexité de la fonction partition en espace et en temps ? quicksort : α list → α list

quicksort l retourne une liste u triée ayant les mêmes éléments que l avec la même multiplicité.

let rec quicksort l = matchl with

| [ ] → [ ]

| x :: r → let(u1, u2) = partition x r in let v1 = quicksort u1 in let v2 = quicksort u2 in v1 @ (x ::v2)

6.2.3 Complexité

Considérons une liste lde longueur n, avec n >0. Notre fonction partitionne l privée de son premier élément, pour obtenir deux listes u₁ et u₂. En notant n₁ et n₂ leurs longueurs respectives, on a n₁+n₂ =l−1.

Le coût en temps^{quicksort l}, aveclnon vide est égal à la somme des coûts des deux appels récursifs, plus celui du partitionnement et de la concaténation, plus quelques coûts en temps constants (filtrage de la liste, destructuration du couple renvoyé parpartition, cons).

Le coût en temps de partition étant dominé par la taille de la liste passée en argu- ment, on peut écrire qu’il existe deux constantes α etβ telles que le temps de calcul de partition x r est majoré parα|r|+β pour toute lister et toutx.

Il existe donc une constanteγ telle que le temps de calcul de^{quicksort l} est majoré par α(n−1) +β+γ, plus le temps de calcul des appels récursifs.

Notons N le nombre d’appels total à quicksort effectués lors de l’évaluation de quicksort l et S la somme des longueurs des listes lors de tous ces appels. Le temps d’exécution de^{quicksort l} est majoré parαS+ (β+γ−α)N.

OrαS+ (β+γ−α)N ≤C(S+N), où C= max(α,β+γ−α).

Version

préliminaire

Donc le temps d’exécution de^{quicksort l} est dominé parN +S.

Notons, pourn∈N, lors de l’évaluation de^{quicksort l}, oùlest une liste de longueur n, la somme du nombre total d’appels à ^quicksort et de la somme des longueurs de toutes les listes sur lesquelles^quicksortdans le cas le pire (c’est-à-dire pour une listel de longueurnpour laquelle cette somme est maximale).

Pour toute valeur den >0, il existek∈[[0, n[[vérifiantP(n)≤P(k)+P(n−1−k)+n. De plusP(0) = 1.

On montre alors que pour tout n, on a P(n) ≤ (n+ 1)². En effet supposons que ce ne soit pas le cas et considérons unnminimal constituant un contre-exemple. Si n= 0, c’est absurde, car P(0) = 1 ≤ (n+ 1)². Si n > 0, alors il existe k ∈ [[0, n[[ vérifiant P(n)≤P(k) +P(n−1−k) +n. On ak < netn−1−k < n, donc par maximalité de n,P(k)≤(k+ 1)² etP(n−1−k)≤(n−1−k+ 1)².

On en déduit

P(n)≤(k+ 1)²+ (n−k)²+n

≤k²+ 2k+ 1 +n²−2nk+k²+n

≤n²+ 2n+ 1 + 2k²+ 2k−2nk−n

≤(n+ 1)²+ 2k(k+ 1−n)−n

≤(n+ 1)²

Le temps d’exécution de ^{quicksort l}, dans le cas le pire, est donc O(n²).

Cette majoration est serrée, comme on peut s’en convaincre en regardant ce qu’il se passe lorsqu’on donne une liste triée à notre fonction^quicksort.

On peut montrer que, dans le cas le meilleur, le tri rapide trie une liste de taille nen O(nlogn).

Enfin, on peut montrer que, si la liste ne comporte aucun doublon et que l’on choisit à chaque appel le pivot au hasard uniformément dans la liste, alors l’espérance du temps de calcul estO(nlogn).