Tris: Introduction

1
Tris Introduction

• IFT 1025 Programmation 2
• Jian-Yun Nie

2
Trier les données

• Créer un ordre dans les données
• Ex. Ordre croissant, décroissant des valeurs
  numériques
• Ordre croissant des mots,
• Pourquoi trier?
• Faciliter la recherche (voir plus tard)
• Faciliter la gestion en générale

3
Exemple

• Trier en ordre croisant
• 2, 56, 4, -7, 0, 78, -45, 10
• Une solution intuitive
• Prendre le plus petit
• Prendre le plus petit suivant
• -45, -7, 0, 2, 4, 10, 56, 78
• Selection sort (Tri par sélection)

4
Principe Selection Sort

• Pour un tableau
• Déterminer le plus petit élément p à partir de i
• Échanger lélément p avec i
• Continuer à partir de i1
• 2, 56, 4, -7, 0, 78, -45, 10
• -45, 56, 4, -7, 0, 78, 2, 10
• -45, 56, 4, -7, 0, 78, 2, 10
• -45, -7, 4, 56, 0, 78, 2, 10
• -45, -7, 4, 56, 0, 78, 2, 10
• -45, -7, 0, 4, 56, 78, 2, 10

5
Tri par insertion

• Pour un tableau
• Prendre lélément i
• Insérer i dans lordre entre 0 et i
• Continuer à partir de i1
• 2, 56, 4, -7, 0, 78, -45, 10
• 2, 56, 4, -7, 0, 78, -45, 10
• 2, 56, 4, -7, 0, 78, -45, 10
• 2, 4, 56, -7, 0, 78, -45, 10
• -7, 2, 4, 56, 0, 78, -45, 10
• -7, 0, 2, 4, 56, 78, -45, 10

6
Tri par insertion (bis)

• Pour un tableau
• Prendre lélément i
• Insérer i dans lordre entre i et la fin
• Continuer avec i-1
• 2, 56, 4, -7, 0, 78, -45, 10
• 2, 56, 4, -7, 0, 78, -45, 10
• 2, 56, 4, -7, 0, 78, -45, 10
• 2, 56, 4, -7, 0, -45, 10, 78
• 2, 56, 4, -7, -45, 0, 10, 78
• 2, 56, 4, -45, -7, 0, 10, 78

7
Principe général de tri

• Diviser pour régner
• Tri par sélection
• Diviser en deux parties (étape difficile)
• Le plus petit élément
• Le reste
• Pour chaque partie divisée
• Trier séparément (récursion)
• Fusionner les résultats
• Plus petit reste trié

8
Principe général de tri (bis)

• Diviser pour régner
• Tri par insertion
• Diviser en deux parties
• Le premier élément
• Le reste
• Pour chaque partie divisée
• Trier séparément (récursion)
• Fusionner les résultats (étape difficile)
• Insérer le premier élément dans le reste trié

9
Illustration

• Sélection Insertion

6 3 2 9 4 5
6 3 2 9 4 5
6 3 9 4 5
2
3 2 9 4 5
6
3 4 5 6 9
2
2 3 4 5 9
6
2 3 4 5 6 9
2 3 4 5 6 9
10
Algorithme par sélection

• Tri par sélection itératif
• public void selectionSort(int array)
• int minIndex, temp
• // Itération
• for (i0 iltarray.length-1 i)
• // Trouver le plus petit élément à partir de i
• minIndexi
• for (ji1 jltarray.length j)
• if arrayjltarrayminIndex minIndexj
• // échanger i et min (swap(array,i,minIndex))
• if (minIndex ! i) temparrayi
• arrayiarrayminIndex
• arrayminIndextemp

11
Algorithme par sélection

• public void selectionSort(int array)
• // Itération
• for (i0 ilttab.length-1 i)
• // Trouver le plus petit élément à partir de i
• int minIndex min(array,i)
• // échanger i et min défini précédemment
• swap(array, i, minIndex)

12
Tri par sélection (récursif)

• public void selectionSort(int array, int
  startIndex)
• if ( startIndex gt array.length - 1 )
• return
• // Trouver min
• int minIndex startIndex
• for ( int index startIndex 1 index lt
  array.length index )
• if (arrayindex lt arrayminIndex )
• minIndex index
• // swap(array,startIndex, minIndex)
• swap(array, startIndex, minIndex)
• // Récursion
• selectionSort(array, startIndex 1)

13
Trouver minIndex (récursif)

• // trouver lindexe de lélément minimal
• public int min(int array, int startIndex)
• int minReste
• if ( startIndex gt array.length - 1 )
• return startIndex
• // trouver min pour le reste
• minReste min(array, startIndex1)
• // choisir entre startIndex et minReste
• if (arraystartIndexltarrayminReste)
• return startIndex
• else return minReste

14
Tri par sélection (récursif)

• void selectionSort(int array, int startIndex)
• if ( startIndex gt array.length - 1 )
• return
• // Trouver min
• int minIndex min(array,startIndex)
• // Swap
• swap(array, startIndex, minIndex)
• // Récursion
• selectionSort(array, startIndex 1)

swap(array,startIndex,
min(array,startIndex))
15
Illustration

• selectionSort(array,0)

6 3 2 9 4 5
swap(0,min(array,0))
3 6 9 4 5
2
selectionSort(array,1)
3 4 5 6 9
2
2 3 4 5 6 9
16
Tri par insertion (itératif)

• void insertionSort(int array, int startIndex)
• for (int i 1 i lt array.length i)
• int next arrayi
• // de i-1 vers le début, décaler les
  éléments gt ai
• int j i
• while (j gt 0 arrayj - 1 gt next)
• arrayj arrayj - 1
• j--
• // Inserer lélément
• arrayj next

17
Illustration

• 2, 56, 4, -7, 0, 78, -45, 10
• 2, 56, 4, -7, 0, 78, -45, 10
• 2, 4, 56, -7, 0, 78, -45, 10
• 2, 4, 56, -7, 0, 78, -45, 10
• 2, 4, 56, 56, 0, 78, -45, 10
• 2, 4, 4, 56, 0, 78, -45, 10
• 2, 2, 4, 56, 0, 78, -45, 10
• -7, 2, 4, 56, 0, 78, -45, 10
• -7, 0, 2, 4, 56, 78, -45, 10
• ...

// de i-1 vers le début, décaler les éléments gt
ai i3 ai-7 next -7
aj next
18
Tri par insertion (récursif)

• void insertionSort(int array, int startIndex)
• if ( startIndex gt array.length - 1 )
• return
• // Trier le reste
• insertionSort(array, startIndex 1)
• // Insérer startIndex dans le reste
• insert(array, startIndex)

19
Insérer

• // insérer lélément index dans le reste qui est
  déjà trié
• public void insert(int array, int index)
• if (index gt array.length-1) return
• if (arrayindex lt arrayindex1) return
• swap(array, index, index1) //arrayindexgtarray
  index1
• insert(array, index1)

Arrêt de récursion
20
Illustration insert

• 6, 2, 3, 4, 5, 9 insert(array, 0)
• 2, 6, 3, 4, 5, 9 insert(array, 1)
• 2, 3, 6, 4, 5, 9 insert(array, 2)
• 2, 3, 4, 6, 5, 9 insert(array, 3)
• 2, 3, 4, 5, 6, 9 insert(array, 4)
• public void insert(int array, int index)
• if (index gt array.length-1) return
• if (arrayindex lt arrayindex1) return
• swap(array, index, index1)
• insert(array, index1)

21
Illustration insertionSort

• insertionSort(array,0)
• insertionSort(array,1)
• insert(array,1)

6 3 2 9 4 5
3 2 9 4 5
6
2 3 4 5 9
6
2 3 4 5 6 9
22
mergeSort et quickSort

• mergeSort quickSort

5 3 2 9 4 6
5 3 2 9 4 6
9 4 6
5
5 3 2
3 2 4
9 6
4 6 9
2 3 5
5
3 2 4
9 6
2 3 4 5 6 9
2 3 4 5 6 9
23
mergeSort

• Tri par fusion
• Principe
• Séparer lensemble de données en 2 parties de
  tailles comparables
• Trier les 2 parties séparément
• Fusionner les deux parties triées

24
quickSort

• Principe
• Déterminer un pivot au hasard (e.g. premier
  élément)
• Séparer les données en 2 parties
• lt pivot
• gt pivot
• Trier les deux parties séparément
• Mettre ensemble ltpivot (pivot) gtpivot

25
mergeSort

• public int mergeSort(int array)
• int array1, array2
• // condition darrêt
• if (array.length lt 1) return
• // séparer en 2 parties
• int first new intarray.length / 2
• int second new intarray.length -
  first.length
• System.arraycopy(array, 0, first, 0,
  first.length)
• System.arraycopy(array, first.length, second,
  0, second.length)
• // trier
• array1 mergeSort(first)
• array2 mergeSort(second)
• // fusionner
• return merge(array1, array2)

return merge(mergeSort(first), mergeSort(second))
26
Merge fusionner deux ensembles triés

• public int merge(int array1, int array2)
• int result new intarray1.lengtharray2.leng
  th
• int i0, j0, k0
• // copier à chaque boucle celui qi est plus petit
• while (iltarray1.length jltarray2.length)
• if (array1i lt array2j)
• resultkarray1i
• i
• else
• resultkarray2j
• j
• k

27
quickSort

• public void quickSort(int array, int from, int
  to)if (from gt to) return
• int p partition(array, from,
  to)quickSort(array, from, p)quickSort(array,
  p 1, to)

28
partition
29
partition

• public int partition(int array, int from, int
  to)
• int pivot arrayfromint i from - 1int
  j to 1while (i lt j) i while (arrayi
  lt pivot) i j-- while (arrayj gt pivot)
  j-- if (i lt j) swap(array,i, j)return j

30
Partition (bis)

• public int partition(int array, int from, int
  to)
• int pivot arrayfromint p from
• for (int r from1 rltto r)
• if (arrayr lt pivot)
• arrayp arrayr
• arrayr arrayp1
• arrayp1 pivot
• p
• return p

ltpivot
gtpivot
r
1
4
p
2
3
pivot
31
Qualité dun algorithme

• Efficacité
• Utilisation de lespace (octets, )
• Utilisation du temps (seconde, )
• Complexité asymptotique
• Imaginons quil y a n données à traiter
• Déterminer lordre de grandeur pour le nombre
  dopérations et dunité despace
• Notation O(n)

32
Complexité

• Temps
• Moyen
• Pire cas
• Ignorer la constante multiplicateur, constante et
  ordre inférieur
• O(3n)O(n)
• Dans une boucle, une opération v.s. 3 opérations
• O(3nlogn)O(n)
• Important
• Nombre de fois quon fait des boucles

33
Illustration

• Sélection
• n éléments
• Pour choisir lélément
• n-1 comparaisons
• récursion
• mettre ensemble
• 1 opération

6 3 2 9 4 5
6 3 9 4 5
2
3 4 5 6 9
2
2 3 4 5 6 9
34
Selection sort (Décomposition)

• (n-1) 1 n éléments
• (n-2) 1 n-1 éléments
• (n-3) 1 n-2 éléments
• 1 1 2 éléments
• n(n-1)/2
• O(n2)
• temps moyen pire cas
• Espace O(1)

35
Merge sort

• Séparer en 2 parties
• 1-2 opérations
• Trier les deux
• Merge
• n comparaisons

5 3 2 9 4 6
9 4 6
5 3 2
4 6 9
2 3 5
2 3 4 5 6 9
36
Merge sort (décomposition)

• 1 (séparer) n (merge) n1
• 2 (séparer) 2n/2 (merges) n2
• 4 (séparer) 4n/4 (merges) n4 logn
• 2logn (séparer) 2lognn/2logn (merges) nn
• Global O(n logn)
• Cas moyen pire cas
• Espace O(n)
• Reflexions
• Temps pour insertionSort et quickSort?
• Espace?

37
Temps typiques pour le tri
Time
n2
n log n
n
n 10 100
1000 n2 100 10,000
1,000,000 n log n 10 200
3000
38
Comparaison
n Merge sort (ms) Selection sort (ms)
10,000 31 772
20,000 47 3,051
30,000 62 6,846
40,000 80 12,188
50,000 97 19,015
60,000 113 27,359
39
Comparaison
40
java.util.Arrays

• Provides static methods for dealing with arrays.
• Works for arrays of numbers, Strings, (and
  comparable Objects).
• Methods

int pos Arrays.binarySearch (arr,
target) Arrays.sort (arr) Arrays.sort (arr,
from, to) //quicksort Arrays.fill (arr, value)
// fills arr with a given value Arrays.fill
(arr, from, to, value)
41
Trier dautres types de données

• Interface Comparable
• Méthode exigée int compareTo(Object o)
• Ordre
• lt0, lt0, 0, gt0, gt0
• Les classes qui implentent Comparable
• BigDecimal, BigInteger, Byte, ByteBuffer,
  Character, CharBuffer, Charset, CollationKey,
  Date, Double, DoubleBuffer, File, Float,
  FloatBuffer, IntBuffer, Integer, Long,
  LongBuffer, ObjectStreamField, Short,
  ShortBuffer, String, URI
• E.g. String s if (s.compareTo("Montreal")lt0)

42
Pour trier dautres données

• class Donnee implements Comparable
• public int compareTo(Object d)
• Donnee d1 (Donnee) d

43
Trier dautres données

• Donnee array
• Arrays.sort(array)
• Reflexion
• Comment modifier les méthodes de tri pour
  fonctionner sur tout tableau (Array) du type
  Comparable?
• public void insertionSort(Comparable array)