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

Præsentationer af emnet: "MM4 Algoritmiske grundprincipper. MM1 Lister, stakke og køer. MM2 Hash-tabeller og Træer. MM3 Sortering.MM4 Søgning.MM5."— Præsentationens transcript:

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 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. 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9

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

5 Insertion Sort. 1 2 3 4 5 6 7 8 9 10 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++; }

6 Insertion Sort. 1 2 4 5 6 7 8 9 10 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++; } 3 3

7 Insertion Sort. 1 2 4 5 6 7 8 9 10 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++; } 33 1

8 Insertion Sort. 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 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++; } Kompleksiteten: O(n*n)

9 Insertion Sort. 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++; } In-space sort. 1 2 3 4 5 6 7 8 9 10

10 Insertion Sort. 1 2 3 4 5 6 7 8 9 10 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++; } In-space sort. i= 1

11 Insertion Sort. 1 2 3 4 5 6 7 8 9 10 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++; } In-space sort. i= 2

12 Insertion Sort. 1 2 3 4 5 6 7 8 9 10 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++; } In-space sort. i= 3

13 Insertion Sort. 1 2 3 4 5 6 7 8 9 10 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++; } In-space sort. i= 4

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

17 judvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j)

18 judvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j)

19 judvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j)

20 judvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j)

21 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j) j

22 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10i k 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); } elm(j) j

23 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j) j

24 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 ik 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); } elm(j) j

25 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j) j

26 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j) j

27 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j) j

28 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j) j

29 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j) j

30 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 ik 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); } elm(j) j

31 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j) j

32 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j) j

33 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j) j

34 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 ik 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); } elm(j) j

35 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j) j

36 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j) j

37 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j) j

38 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j) j

39 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j) j

40 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 ik 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); } elm(j) j

41 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j) j

42 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j) j

43 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j) j

44 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j) j

45 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 i k 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); } elm(j) j

46 udvalgt værdi: Quicksort. 1 2 3 4 5 6 7 8 9 10 ik 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); } elm(j) j

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

51 Merge Sort. 1 2 3 6 9 4 5 7 8 10 1 2 3 4 5 6 7 8 9 1 2 9 4 5 8 7 6 3 9 2 8 5 7 3 6 1 9 2 4 8 5 2 92 9 1 3 6 5 85 8 4 7 6 9 3 1 2 8 7 4 5 4 5 3 1 2 9 8 6 7

52 int mgsort(void *data, int size, int esize, int i, int k) { int j; if (i < k) { j = (int)(((i + k - 1)) / 2); if (mgsort(data, size, esize, i, j) < 0) return -1; if (mgsort(data, size, esize, j + 1, k) < 0) return -1; if (merge(data, esize, i, j, k) < 0) return -1; } return 0; } Merge Sort.

53 Fordel: Simpel. Kan anvendes til delsortering. Kompleksiteten: O(n*log(n)) Stabil Ulemper: Kræver ekstra lager.

54 Counting Sort. 1335277165 Data: Counters: Temp: 00222112 Trin 1: Tæl hvor mange gange de enkelte tal indgår i datasættet.

55 Counting Sort. 1335277165 Data: Counters: Temp: 0 02 2 2112 Trin 2: Lad tallene i ’Counters’ angive hvor mange tal der til og med det pågældende tal. 3557810

56 Counting Sort. 1335277165 Data: Counters: Temp: 0 02 2 2112 Trin 3: for (j = size - 1; j >= 0; j--) { temp[counts[data[j]]-1] = data[j]; counters[data[j]] = counters[data[j]] - 1; } 3557810 2

57 Counting Sort. 1335277165 Data: Counters: Temp: 0 02 2 2112 Trin 3: for (j = size - 1; j >= 0; j--) { temp[counts[data[j]]-1] = data[j]; counters[data[j]] = counters[data[j]] - 1; } 2557810 2

58 Counting Sort. 1335277165 Data: Counters: Temp: 0 02 2 2112 Trin 3: for (j = size - 1; j >= 0; j--) { temp[counts[data[j]]-1] = data[j]; counters[data[j]] = counters[data[j]] - 1; } 2557810 21

59 Counting Sort. 1335277165 Data: Counters: Temp: 0 02 1 2112 Trin 3: for (j = size - 1; j >= 0; j--) { temp[counters[data[j]]-1] = data[j]; counters[data[j]] = counters[data[j]] - 1; } 2557810 21

60 Counting Sort. 1335277165 Data: Counters: Temp: 0 02 1 2112 Trin 3: for (j = size - 1; j >= 0; j--) { temp[counts[data[j]]-1] = data[j]; counters[data[j]] = counters[data[j]] - 1; } 2557810 217

61 Counting Sort. 1335277165 Data: Counters: Temp: 0 02 1 2112 Trin 3: for (j = size - 1; j >= 0; j--) { temp[counts[data[j]]-1] = data[j]; counters[data[j]] = counters[data[j]] - 1; } 255789 217

62 Counting Sort. 1335277165 Data: Counters: Temp: 0 02 1 2112 Trin 3: for (j = size - 1; j >= 0; j--) { temp[counts[data[j]]-1] = data[j]; counters[data[j]] = counters[data[j]] - 1; } 255789 2175

63 Counting Sort. 1335277165 Data: Counters: Temp: 0 02 1 2112 Trin 3: for (j = size - 1; j >= 0; j--) { temp[counts[data[j]]-1] = data[j]; counters[data[j]] = counters[data[j]] - 1; } 255689 2175

64 Counting Sort. 1335277165 Data: Counters: Temp: 0 02 0 2112 Trin 3: for (j = size - 1; j >= 0; j--) { temp[counts[data[j]]-1] = data[j]; counters[data[j]] = counters[data[j]] - 1; } 235568 2175361357

65 Counting Sort. Fordel: Simpel. Kan anvendes til delsortering. Komptiksiteten: O(n + K) hvor K= max(Xn) +1; Stabil. Ulemper: Kan kun sortere hel tal. Skal kende det største tal.

66 Radix Sort. Anvendt til flere cifret tal fx Radix-10 til tal i Ti-tals systemet. 43 756 323 462 55 123 839 857 9 130 Fremgangsmåde: 1.Sorter efter mindst betydende ciffer. 2.Sorter efter 2. mindst betydende ciffer. 3.Sorter efter 3. mindst betydende ciffer............ n. Sorter efter mest betydende ciffer.

67 Radix Sort. Anvendt til flere cifret tal fx Radix-10 til tal i Ti-tals systemet. 43 756 323 462 55 123 839 857 9 130 Fremgangsmåde: 1.Sorter efter mindst betydende ciffer. 2.Sorter efter 2. mindst betydende ciffer. 3.Sorter efter 3. mindst betydende ciffer............ n. Sorter efter mest betydende ciffer.

68 Radix Sort. Anvendt til flere cifret tal fx Radix-10 til tal i Ti-tals systemet. 43 756 323 462 55 123 839 857 9 130 Fremgangsmåde: 1.Sorter efter mindst betydende ciffer. 2.Sorter efter 2. mindst betydende ciffer. 3.Sorter efter 3. mindst betydende ciffer............ n. Sorter efter mest betydende ciffer.

69 Radix Sort. Anvendt til flere cifret tal fx Radix-10 til tal i Ti-tals systemet. 43 756 323 462 55 123 839 857 9 130 Fremgangsmåde: 1.Sorter efter mindst betydende ciffer. 2.Sorter efter 2. mindst betydende ciffer. 3.Sorter efter 3. mindst betydende ciffer............ n. Sorter efter mest betydende ciffer.

70 Radix Sort. Anvendt til flere cifret tal fx Radix-10 til tal i Ti-tals systemet. 43 756 323 462 55 123 839 857 9 130 Fremgangsmåde: 1.Sorter efter mindst betydende ciffer. 2.Sorter efter 2. mindst betydende ciffer. 3.Sorter efter 3. mindst betydende ciffer............ n. Sorter efter mest betydende ciffer.

71 Radix Sort. Anvendt til flere cifret tal fx Radix-10 til tal i Ti-tals systemet. 43 756 323 462 55 123 839 857 9 130 Fremgangsmåde: 1.Sorter efter mindst betydende ciffer. 2.Sorter efter 2. mindst betydende ciffer. 3.Sorter efter 3. mindst betydende ciffer............ n. Sorter efter mest betydende ciffer.

72 Radix Sort. Anvendt til ord fx Radix-28. bi sodavand Konfirmation bil elefant ordbog øl vin sko ø Fremgangsmåde: 1.Sorter efter mindst betydende bogstav. 2.Sorter efter 2. mindst betydende bogstav. 3.Sorter efter 3. mindst betydende bogstav............ n. Sorter efter mest betydende bogstav.

73 Radix Sort. Anvendt til ord fx Radix-28. bi sodavand Konfirmation bil elefant ordbog øl vin sko ø Fremgangsmåde: 1.Sorter efter mindst betydende bogstav. 2.Sorter efter 2. mindst betydende bogstav. 3.Sorter efter 3. mindst betydende bogstav............ n. Sorter efter mest betydende bogstav.

74 Radix Sort. Anvendt til ord fx Radix-28. bi sodavand Konfirmation bil elefant ordbog øl vin sko ø Fremgangsmåde: 1.Sorter efter mindst betydende bogstav. 2.Sorter efter 2. mindst betydende bogstav. 3.Sorter efter 3. mindst betydende bogstav............ n. Sorter efter mest betydende bogstav.

75 Radix Sort. Anvendt til ord fx Radix-28. bi sodavand Konfirmation bil elefant ordbog øl vin sko ø Fremgangsmåde: 1.Sorter efter mindst betydende bogstav. 2.Sorter efter 2. mindst betydende bogstav. 3.Sorter efter 3. mindst betydende bogstav............ n. Sorter efter mest betydende bogstav.

76 Radix Sort. Anvendt til ord fx Radix-28. bi sodavand Konfirmation bil elefant ordbog øl vin sko ø Fremgangsmåde: 1.Sorter efter mindst betydende bogstav. 2.Sorter efter 2. mindst betydende bogstav. 3.Sorter efter 3. mindst betydende bogstav............ n. Sorter efter mest betydende bogstav.

77 Radix Sort. Anvendt til ord fx Radix-28. bi sodavand Konfirmation bil elefant ordbog øl vin sko ø Fremgangsmåde: 1.Sorter efter mindst betydende bogstav. 2.Sorter efter 2. mindst betydende bogstav. 3.Sorter efter 3. mindst betydende bogstav............ n. Sorter efter mest betydende bogstav.

78 Radix Sort. Anvendt til ord fx Radix-28. bi sodavand Konfirmation bil elefant ordbog øl vin sko ø Fremgangsmåde: 1.Sorter efter mindst betydende bogstav. 2.Sorter efter 2. mindst betydende bogstav. 3.Sorter efter 3. mindst betydende bogstav............ n. Sorter efter mest betydende bogstav.

79 Radix Sort. Anvendt til ord fx Radix-28. bi sodavand Konfirmation bil elefant ordbog øl vin sko ø Fremgangsmåde: 1.Sorter efter mindst betydende bogstav. 2.Sorter efter 2. mindst betydende bogstav. 3.Sorter efter 3. mindst betydende bogstav............ n. Sorter efter mest betydende bogstav.

80 Radix Sort. Anvendt til ord fx Radix-28. bi sodavand Konfirmation bil elefant ordbog øl vin sko ø Fremgangsmåde: 1.Sorter efter mindst betydende bogstav. 2.Sorter efter 2. mindst betydende bogstav. 3.Sorter efter 3. mindst betydende bogstav............ n. Sorter efter mest betydende bogstav.

81 Radix Sort. Anvendt til ord fx Radix-28. bi sodavand Konfirmation bil elefant ordbog øl vin sko ø Fremgangsmåde: 1.Sorter efter mindst betydende bogstav. 2.Sorter efter 2. mindst betydende bogstav. 3.Sorter efter 3. mindst betydende bogstav............ n. Sorter efter mest betydende bogstav.

82 Radix Sort. Anvendt til ord fx Radix-28. bi sodavand Konfirmation bil elefant ordbog øl vin sko ø Fremgangsmåde: 1.Sorter efter mindst betydende bogstav. 2.Sorter efter 2. mindst betydende bogstav. 3.Sorter efter 3. mindst betydende bogstav............ n. Sorter efter mest betydende bogstav.

83 Radix Sort. Anvendt til ord fx Radix-28. bi sodavand Konfirmation bil elefant ordbog øl vin sko ø Fremgangsmåde: 1.Sorter efter mindst betydende bogstav. 2.Sorter efter 2. mindst betydende bogstav. 3.Sorter efter 3. mindst betydende bogstav............ n. Sorter efter mest betydende bogstav.

84 Radix Sort. Anvendt til ord fx Radix-28. bi sodavand Konfirmation bil elefant ordbog øl vin sko ø Fremgangsmåde: 1.Sorter efter mindst betydende bogstav. 2.Sorter efter 2. mindst betydende bogstav. 3.Sorter efter 3. mindst betydende bogstav............ n. Sorter efter mest betydende bogstav.

85 Konklusion Quicksort: Effektiv og in-place algoritme Merge Sort: Effektiv kræver ekstra plads. Insertion Sort: Ineffektiv men kan anvendes som incremental sortering. Counting Sort: Effektiv kræver ekstra plads og kan kun anvendes til sortering af begrænsede hel tal. Radix Sort: Bygger på en stabil algoritme fx Counting Sort.