(********** ICI ON CHERCHE A EFFECTUER UN TRI DANS L'ORDRE CROISSANT ******************)


(**************************************************************************************)
(* 1- tri par minimum :                                                               *)
(* le plus simple et le moins efficace, on chercher le "minimum" (resp. le maximum)   *)
(* on le range en fin de liste puis on le "supprime" de la liste et on cherche le     *)
(* minimum du reste de la liste                                                       *)
(**************************************************************************************)

let rec minimum liste = ...
(* minimum [3;2;1] renvoie 1 *)

let rec supprime x liste = ...
(* supprime 2 [3;2;1] renvoie [3;1] *)

let rec triMini liste = ...
(* triMini [3;2;1] renvoie [1;2;3] *)






(**************************************************************************************)
(* 2- tri par insertion :                                                             *)
(* un peu plus élaboré, on prend chaque élément et on l'ajoute à la bonne place dans  *)
(* la liste triée nouvellement construite. On a donc besoin d'une fonction capable    *)
(* d'ajouter un élément à la bonne place dans une liste triée                         *)
(**************************************************************************************)

let rec insertCroissant x liste = ...
(* insertCroissant 4 [1;2;10] renvoie [1;2;4;10] *)

let rec triInsert liste = ...
(* triInsert [3;2;1] renvoie [1;2;3] *)







(**************************************************************************************)
(* 3- tri fusion :                                                                    *)
(* on divise la liste en 2 parties égales (ou presque dans le cas impair), par        *)
(* on peut prendre un élément sur deux dans la première partie et inversement, puis   *)
(* on trie chaque partie séparemment et on fusionne les parties triées. Bien sur on   *)
(* va effectuer cette division jusqu'à arriver à des éléments simples, ce qui fait    *)
(* que l'ensemble du tri sera fait par l'opération de fusion                          *)
(**************************************************************************************)

let rec division liste = ...
(* division [6;5;4;3;2;1] renvoie [6;4;2],[5;3;1] (un couple)*)

let rec fusion l1 l2 = ...
(* fusion [1;4;5] [2;3;6] renvoie [1;2;3;4;5;6] *)

let rec triFusion liste = ...
(* triFusion [3;2;1] renvoie [1;2;3] *)







(**************************************************************************************)
(* 4- tri rapide :                                                                    *)
(* ici le secret tient au fait qu'on se choisit un pivot grace auquel                 *)
(* on divise la liste à trier en deux. Chaque élément de la liste est rangé dans une  *)
(* des deux parties selon qu'il est plus grand ou moins grand que le pivot.           *)
(* Il s'agit d'un tri assez semblable au tri fusion (on divise successivement par 2)  *)
(* sauf qu'ici on se passe complètement de la partie fusionnage...                    *)
(* On pourra ici se choisir comme pivot la valeur du premier élément de la liste.     *)
(* (par contre le choix du pivot peut s'avérer déterminant dans les perfs du tri)     *)
(**************************************************************************************)

let rec partition liste pivot = ...
(* partition [5;2;6;3;8;1;4;7] 5 renvoie [2;3;1;4],[5;6;8;7] (un couple)*)

let rec triRapide liste = ...
(* triRapide [3;2;1] renvoie [1;2;3] *)