La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

Tris: Introduction IFT 1025: Programmation 2 Jian-Yun Nie.

Présentations similaires


Présentation au sujet: "Tris: Introduction IFT 1025: Programmation 2 Jian-Yun Nie."— Transcription de la présentation:

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 i+1 2, 56, 4, -7, 0, 78, -45, , 56, 4, -7, 0, 78, 2, , -7, 4, 56, 0, 78, 2, , -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 i+1 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, -45, 10, 78 2, 56, 4, 56, -45, 0, 10, 78 2, 56, 4, -45, 0, 10, 56, 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électionInsertion

10 Algorithme: par sélection Tri par sélection itératif: public void selectionSort(int[] array) int minIndex, temp; // Itération for (i=0; i

11 Algorithme: par sélection public void selectionSort(int[] array) { // Itération for (i=0; i

12 Tri par sélection (récursif) public void selectionSort(int[] array, int startIndex) { if ( startIndex >= array.length - 1 ) return; // Trouver min int minIndex = startIndex; for ( int index = startIndex + 1; index < array.length; index++ ) { if (array[index] < array[minIndex] ) 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 >= array.length - 1 ) return startIndex; // trouver min pour le reste minReste = min(array, startIndex+1); // choisir entre startIndex et minReste if (array[startIndex]

14 Tri par sélection (récursif) void selectionSort(int[] array, int startIndex) { if ( startIndex >= 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) selectionSort(array,1) swap(0,min(array,0))

16 Tri par insertion (itératif) void insertionSort(int[] array, int startIndex) { for (int i = 1; i < array.length; i++) { int next = array[i]; // de i-1 vers le début, décaler les éléments > a[i] int j = i; while (j > 0 && array[j - 1] > next) { array[j] = array[j - 1]; j--; } // Inserer lélément array[j] = next; }

17 Illustration 2, 56, 4, -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, // de i-1 vers le début, décaler les éléments > a[i] i==3 a[i]==-7 next == -7 a[j] = next;

18 Tri par insertion (récursif) void insertionSort(int[] array, int startIndex) { if ( startIndex >= 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 >= array.length-1) return; if (array[index] <= array[index+1]) return; swap(array, index, index+1); //array[index]>array[index+1] insert(array, index+1); } Arrêt de récursion

20 Illustration insert 6, 2, 3, 4, 5, 9insert(array, 0) 2, 6, 3, 4, 5, 9insert(array, 1) 2, 3, 6, 4, 5, 9insert(array, 2) 2, 3, 4, 6, 5, 9insert(array, 3) 2, 3, 4, 5, 6, 9insert(array, 4) public void insert(int [] array, int index) { if (index >= array.length-1) return; if (array[index] < array[index+1]) return; swap(array, index, index+1); insert(array, index+1); }

21 Illustration: insertionSort insertionSort(array,1) insert(array,1)

22 mergeSort et quickSort mergeSortquickSort

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: <= pivot >= pivot –Trier les deux parties séparément –Mettre ensemble: =pivot

25 mergeSort public int[] mergeSort(int [] array) { int [] array1, array2; // condition darrêt if (array.length <= 1) return; // séparer en 2 parties int[] first = new int[array.length / 2]; int[] second = new int[array.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 int[array1.length+array2.length]; int i=0, j=0, k=0; // copier à chaque boucle celui qi est plus petit while (i

27 quickSort public void quickSort(int[] array, int from, int to) { if (from >= to) return; int p = partition(array, from, to); quickSort(array, from, p); quickSort(array, p + 1, to); }

28 partition

29 public int partition(int[] array, int from, int to) { int pivot = array[from]; int i = from - 1; int j = to + 1; while (i pivot) j--; if (i < j) swap(array,i, j); } return j; }

30 Partition (bis) public int partition(int[] array, int from, int to) { int pivot = array[from]; int p = from; for (int r = from+1; r<=to; r++) { if (array[r] < pivot) { array[p] = array[r]; array[r] = array[p+1]; array[p+1] = pivot; p++; } return p; } p >=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 un boucle, une opération v.s. 3 opérations –O(3n+logn)=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

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 … éléments n(n-1)/2 O(n 2 ) 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

36 Merge sort (décomposition) 1 (séparer) + n (merge)= n+1 2 (séparer) + 2*n/2 (merges)= n+2 4 (séparer) + 4*n/4 (merges)= n+4 logn … 2 logn (séparer) + 2 logn *n/2 logn (merges) = n+n Global: O(n logn) Cas moyen = pire cas Espace: O(n) Reflexions: –Temps pour insertionSort et quickSort? –Espace?

37 Temps typiques pour le tri n Time n2n2 n log n n n ,000 1,000,000 n log n

38 Comparaison nMerge sort (ms) Selection sort (ms) 10, ,000473,051 30,000626,846 40, ,188 50, ,015 60, ,359

39 Comparaison

40 java.util.Arrays Provides static methods for dealing with arrays. Works for arrays of numbers, Strings, (andcomparable 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: =0, >0 Les classes qui implentent Comparable: BigDecimalBigDecimal, BigInteger, Byte, ByteBuffer, Character, CharBuffer, Charset, CollationKey, Date, Double, DoubleBuffer, File, Float, FloatBuffer, IntBuffer, Integer, Long, LongBuffer, ObjectStreamField, Short, ShortBuffer, String, URIBigIntegerByteByteBufferCharacter CharBufferCharsetCollationKeyDateDoubleDoubleBuffer FileFloatFloatBufferIntBufferIntegerLongLongBuffer ObjectStreamFieldShortShortBufferStringURI E.g. String s: if (s.compareTo("Montreal")<0) …

42 Pour trier dautres données class Donnee implements Comparable { … public int comparaTo(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)


Télécharger ppt "Tris: Introduction IFT 1025: Programmation 2 Jian-Yun Nie."

Présentations similaires


Annonces Google