Avec 2 arguments
Le deuxième argument doit être une fonction de tri f qui doit définir
un ordre strict faible sinon l’algorithme employé risque de boucler....
c’est à dire que :
f(x,y) est un fonction toujours définie renvoyant 0 (faux) ou 1 (vrai) .
f doit renvoyer 0 si 2 éléments ne sont pas comparables et doit
vérifier :
-
f doit définir une
relation transitive (si f(x,y) et f(y,z) sont vrais alors
f(x,z) est vrai)
- on ne peut pas avoir
f(x,y) et f(y,x) vrai en même temps et f(x,x) est faux (ce que l’on
appelle une antisymétrie non réflexive)
- f ne définit pas forcément une relation
d’ordre total, on peut avoir f(x,y) et f(y,x) simultanément faux.
Si on définit la relation E par x E y est vrai lorsque
f(x,y) et f(y,x) sont simultanément faux
alors E doit être une relation d’équivalence.
Par exemple, on ne peut pas mettre comme
fonction de tri : (x,y)->x[1]>=y[1].
On tape :
sort([3,4,2],(x,y)->x>y)
On obtient :
[4,3,2]
Exemples pour trier des listes de listes
Avec un seul argument, sort trie les listes de listes par ordre croissant.
sort([[1,3],[2,4],[2,3],[1,4]])
On obtient :
[[1,3],[1,4],[2,3],[2,4]]
Pour un ordre différent, il faut mettre
une fonction de tri comme 2ième argument.
Par exemple :
-
Si on veut trier par ordre décroissant la première colonne ou en cas
d’égalité par ordre décroissant la 2ième colonne (ordre
lexicographique pour les 2 premières colonnes).
On tape :
sort([[1,3],[2,4],[2,3],[1,4]],
(x,y)->when(x[0]==y[0],x[1]>y[1],x[0]>y[0]))
On obtient :
[[2,4],[2,3],[1,4],[1,3]]
- Si on veut trier par ordre décroissant la 2ième
colonne ou en cas d’égalité par ordre décroissant la première colonne.
On tape :
sort([[1,3],[2,4],[2,3],[1,4]],
(x,y)->when(x[1]==y[1],x[0]>y[0],x[1]>y[1]))
On obtient :
[[2,4],[1,4],[2,3],[1,3]]
Attention
Dans l’exemple précédent,
-
on ne peut pas mettre comme
fonction de tri
(x,y)->x[1]>=y[1] car l’ordre n’est pas strict
- on peut mettre comme fonction de tri
f:=(x,y)->x[1]>y[1] bien que l’ordre ne soit pas total.
Soient :
L1:=[[1,2],[2,3],[4,3]]
L2:=[[1,2],[4,3],[2,3]]
Dans ce cas :
sort(L1,(x,y)->x[1]>y[1]) et
sort(L2,(x,y)->x[1]>y[1])
renvoient des réponses
différentes parce que l’ordre n’est pas total et que
[2,3] et [4,3] sont considérés comme équivalents.
Exemple pour trier par ordre lexicographique des matrices ou des chaines de caractères
Pour trier par ordre lexicographique des matrices ou des chaines de
caractères, il faut mettre en second argument comme fonction de tri, par
exemple, la fonction booléenne super ci-dessous :
Si L1 et L2 sont 2 listes ou 2 chaines de caractères alors
super(L1,L2) renvoie 1 si L1>L2 et 0 sinon.
On tape :
super(L1,L2):={
local s,j;
s:=min(size(L1),size(L2))-1;
j:=0;
tantque L1[j]==L2[j] and j<s faire
j:=j+1;
ftantque;
//si L2[j]>=L1[j] alors return 0 sinon return 1; fsi;
si [sort(L1[j],L2[j])]==[L1[j],L2[j]] alors
return 0
sinon
return 1;
fsi;
}:;
On a remplacé L2[j]>=L1[j] par [sort(L1[j],L2[j])]==[L1[j],L2[j]]
pour que super soit aussi valable pour les chaines de caractères.
On tape :
sort(["dac","bac","sac","asc","cab"],super)
ou on tape
sort(["dac","bac","sac","asc","cab"],(x,y)->super(x,y))
On obtient :
["sac","dac","cab","bac","asc"]
On tape :
sort([[3,4,2],[4,2,3],[2,3,4],[2,4,3]],super)
ou on tape
sort([[3,4,2],[4,2,3],[2,3,4],[2,4,3]],(x,y)->super(x,y))
On obtient :
[[2,3,4],[2,4,3],[3,4,2],[4,2,3]][[2,3,4],[2,4,3],[3,4,2],[4,2,3]]