MM4

1. MM4 • Algoritmiske grundprincipper. MM1 • Lister, stakke og køer. MM2  • Hash-tabeller og Træer. MM3 • Sortering. MM4 • Søgning. MM5

2. Sortering Sorteringsalgoritmer : • Virkemåde og anvendelser • Kompleksitet • Algoritmen

3. 6 1 3 2 1 3 9 4 2 5 7 6 10 7 4 8 8 9 10 5 Sorteringsalgoritmer Sortering af elementer i en bestemt orden. Anvendelser: • Præsentation af data fx: direktorielisting, søgeresultat, .. • Stavekontrol. • Kartotekssystem. • Bedre søgning. • E-mail. • Osv.

4. Sorteringsalgoritme- typer: Comperison sort: • Insertion Sort. • Quicksort. • Merge Sort. Linear-time sort: • Counting Sort. • Radix Sort.

5. Insertion Sort. 6 6 3 Algoritme: i= 0; while(i<size) { Tage det i’te element. Placer det i’te element på den rigtigt plads i den sorterede del. i++; } 1 9 2 7 10 4 8 5

6. Insertion Sort. 6 3 3 6 Algoritme: i= 0; while(i<size) { Tage det i’te element. Placer det i’te element på den rigtigt plads i den sorterede del. i++; } 1 9 2 7 10 4 8 5

7. Insertion Sort. 6 1 3 3 Algoritme: i= 0; while(i<size) { Tage det i’te element. Placer det i’te element på den rigtigt plads i den sorterede del. i++; } 1 6 9 2 7 10 4 8 5

8. Insertion Sort. 6 1 3 2 Algoritme: i= 0; while(i<size) { Tage det i’te element. Placer det i’te element på den rigtigt plads i den sorterede del. i++; } 1 3 9 4 2 5 7 6 10 7 4 8 8 9 5 10 Kompleksiteten: O(n*n)

9. Insertion Sort. In-space sort. 6 3 Algoritme: i= 1; while(i<size) { Tage det i’te element; Placer det i’te element på den rigtigt plads mellem de ’i’ første elementer. i++; } 1 9 2 7 10 4 8 5

10. Insertion Sort. i= 1 In-space sort. 3 6 Algoritme: i= 1; while(i<size) { Tage det i’te element; Placer det i’te element på den rigtigt plads mellem de ’i’ første elementer. i++; } 1 9 2 7 10 4 8 5

11. Insertion Sort. i= 2 In-space sort. 1 3 Algoritme: i= 1; while(i<size) { Tage det i’te element; Placer det i’te element på den rigtigt plads mellem de ’i’ første elementer. i++; } 6 9 2 7 10 4 8 5

12. Insertion Sort. i= 3 In-space sort. 1 3 Algoritme: i= 1; while(i<size) { Tage det i’te element; Placer det i’te element på den rigtigt plads mellem de ’i’ første elementer. i++; } 6 9 2 7 10 4 8 5

13. Insertion Sort. i= 4 In-space sort. 1 2 Algoritme: i= 1; while(i<size) { Tage det i’te element; Placer det i’te element på den rigtigt plads mellem de ’i’ første elementer. i++; } 3 6 9 7 10 4 8 5

14. Insertion Sort. • Fordel: • Simpel. • In-place sort. • Incremental sort. • Stabil: Hvis R og S har samme key og R kommer før S i • den originale liste, så kommer R før S i den • sorterede liste. • Ulemper: • Kompleksiteten: O(n*n)

15. Insertion Sort. int issort(void *data, int size, int esize) { char *a = data; void *key; int i,j; if ((key = (char *)malloc(esize)) == NULL) return -1; for (j = 1; j < size; j++) { memcpy(key, &a[j * esize], esize); i = j - 1; while (i >= 0 && compare(&a[i * esize], key) > 0) { memcpy(&a[(i + 1) * esize], &a[i * esize], esize); i--; } memcpy(&a[(i + 1) * esize], key, esize); } free(key); return 0; }

16. Quicksort. 6 • En divide-and-conquer algoritme • Fremgangsmåde: • Del de enkelte data værdier i to omkring en udvalgt værdi. • Gør det samme for de to dele af data. • Den udvalgt værdi udvælges tilfældigt, • Evt med midian-of-three metoden. 3 1 9 2 7 10 4 8 5

17. i j k Quicksort. 6 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 3 1 9 2 udvalgt værdi: elm(j) 7 10 4 8 5

18. i j k Quicksort. 6 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 3 1 9 2 udvalgt værdi: elm(j) 7 10 4 8 5

19. i j k Quicksort. 6 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 3 1 5 2 udvalgt værdi: elm(j) 7 10 4 8 9

20. i j k Quicksort. 6 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 3 1 5 2 udvalgt værdi: elm(j) 7 10 4 8 9

21. i j k Quicksort. 6 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 3 1 5 2 udvalgt værdi: elm(j) 4 10 7 8 9

22. i j k Quicksort. 6 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 3 1 5 2 udvalgt værdi: elm(j) 4 10 7 8 9

23. i j k Quicksort. 6 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 3 1 5 2 udvalgt værdi: elm(j) 4 7 10 8 9

24. i j k Quicksort. 6 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 3 1 5 2 udvalgt værdi: elm(j) 4 7 10 8 9

25. i j k Quicksort. 6 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 3 1 5 2 udvalgt værdi: elm(j) 4 7 10 8 9

26. i j k Quicksort. 6 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 3 1 5 2 udvalgt værdi: elm(j) 4 7 10 8 9

27. i j k Quicksort. 4 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 3 1 5 2 udvalgt værdi: elm(j) 6 7 10 8 9

28. i j k Quicksort. 4 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 3 1 5 2 udvalgt værdi: elm(j) 6 7 10 8 9

29. i j k Quicksort. 4 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 3 1 2 5 udvalgt værdi: elm(j) 6 7 10 8 9

30. i j k Quicksort. 4 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 3 1 2 5 udvalgt værdi: elm(j) 6 7 10 8 9

31. i j k Quicksort. 4 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 3 1 2 5 udvalgt værdi: elm(j) 6 7 10 8 9

32. i j k Quicksort. 4 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 3 1 2 5 udvalgt værdi: elm(j) 6 7 10 8 9

33. i j k Quicksort. 1 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 3 4 2 5 udvalgt værdi: elm(j) 6 7 10 8 9

34. i j k Quicksort. 1 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 3 4 2 5 udvalgt værdi: elm(j) 6 7 10 8 9

35. i j k Quicksort. 1 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 3 4 2 5 udvalgt værdi: elm(j) 6 7 10 8 9

36. i j k Quicksort. 1 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 3 4 2 5 udvalgt værdi: elm(j) 6 7 10 8 9

37. i j k Quicksort. 1 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 2 4 3 5 udvalgt værdi: elm(j) 6 7 10 8 9

38. i j k Quicksort. 1 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 2 4 3 5 udvalgt værdi: elm(j) 6 7 10 8 9

39. i j k Quicksort. 1 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 2 3 4 5 udvalgt værdi: elm(j) 6 7 10 8 9

40. i j k Quicksort. 1 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 2 3 4 5 udvalgt værdi: elm(j) 6 7 10 8 9

41. i j k Quicksort. 1 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 2 3 4 5 udvalgt værdi: elm(j) 6 7 10 8 9

42. i j k Quicksort. 1 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 2 3 4 5 udvalgt værdi: elm(j) 6 7 10 8 9

43. i j k Quicksort. 1 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 2 3 4 5 udvalgt værdi: elm(j) 6 7 9 8 10

44. i j k Quicksort. 1 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 2 3 4 5 udvalgt værdi: elm(j) 6 7 9 8 10

45. i j k Quicksort. 1 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 2 3 4 5 udvalgt værdi: elm(j) 6 7 8 9 10

46. i j k Quicksort. 1 Så længe k > i { Find første elm(i) >= elm(j); Find første elm(k) <= elm(j); Opbyt (swap) elm(k) og elm(i); } 2 3 4 5 udvalgt værdi: elm(j) 6 7 8 9 10

47. Quicksort. int qksort(int *data, int i, int k) { int j; if (i < k) { if ((j = partition(data, i, k)) < 0) return -1; if (qksort(data, i, j) < 0)return -1; if (qksort(data, j + 1, k) < 0)return -1; } return 0; }

48. Quicksort. static int partition(int *data, int int i, int k) { int *a = data; int pval, temp; int j; j= (rand() % (k - i + 1)) + i; pval= a[j]; i--;k++; while (1) { do { k--; } while (a[k] >= pval)); do { i++; } while (a[i] <= pval)); if (i >= k) break; else { temp= a[i]; a[i]= &a[k]; a[k]= temp; } } return k; }

49. Quicksort. • Fordel: • In-place sort. • Kompleksiteten: typisk: O(n*log(n)) • Ulemper: • Ikke stabil.

50. Merge Sort. 6 • En divide-and-conquer algoritme, • Ikke in-palce. • Fremgangsmåde: • Del i to halvdele. • Gør det samme som her beskrevet for hver halvdel. • Saml de to halvdele i et sorteret datasæt. 3 1 9 2 7 10 4 8 5