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

Sortering Sorteringsalgoritmer : –Virkemåde og anvendelser –Kompleksitet –Algoritmen

Sorteringsalgoritmer Sortering af elementer i en bestemt orden. Anvendelser: Præsentation af data fx: direktorielisting, søgeresultat,.. Stavekontrol. Kartotekssystem. Bedre søgning. . Osv

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

Insertion Sort 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++; }

Insertion Sort 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

Insertion Sort 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

Insertion Sort 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)

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

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. i= 1

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. i= 2

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. i= 3

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. i= 4

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)

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; }

Quicksort 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.

judvalgt værdi: Quicksort 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)

judvalgt værdi: Quicksort 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)

judvalgt værdi: Quicksort 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)

judvalgt værdi: Quicksort 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)

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

udvalgt værdi: Quicksort 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

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; }

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; }

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

Merge Sort 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.

Merge Sort

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.

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

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

Counting Sort Data: Counters: Temp: Trin 2: Lad tallene i ’Counters’ angive hvor mange tal der til og med det pågældende tal

Counting Sort Data: Counters: Temp: Trin 3: for (j = size - 1; j >= 0; j--) { temp[counts[data[j]]-1] = data[j]; counters[data[j]] = counters[data[j]] - 1; }

Counting Sort Data: Counters: Temp: Trin 3: for (j = size - 1; j >= 0; j--) { temp[counts[data[j]]-1] = data[j]; counters[data[j]] = counters[data[j]] - 1; }

Counting Sort Data: Counters: Temp: Trin 3: for (j = size - 1; j >= 0; j--) { temp[counts[data[j]]-1] = data[j]; counters[data[j]] = counters[data[j]] - 1; }

Counting Sort Data: Counters: Temp: Trin 3: for (j = size - 1; j >= 0; j--) { temp[counters[data[j]]-1] = data[j]; counters[data[j]] = counters[data[j]] - 1; }

Counting Sort Data: Counters: Temp: Trin 3: for (j = size - 1; j >= 0; j--) { temp[counts[data[j]]-1] = data[j]; counters[data[j]] = counters[data[j]] - 1; }

Counting Sort Data: Counters: Temp: Trin 3: for (j = size - 1; j >= 0; j--) { temp[counts[data[j]]-1] = data[j]; counters[data[j]] = counters[data[j]] - 1; }

Counting Sort Data: Counters: Temp: Trin 3: for (j = size - 1; j >= 0; j--) { temp[counts[data[j]]-1] = data[j]; counters[data[j]] = counters[data[j]] - 1; }

Counting Sort Data: Counters: Temp: Trin 3: for (j = size - 1; j >= 0; j--) { temp[counts[data[j]]-1] = data[j]; counters[data[j]] = counters[data[j]] - 1; }

Counting Sort Data: Counters: Temp: Trin 3: for (j = size - 1; j >= 0; j--) { temp[counts[data[j]]-1] = data[j]; counters[data[j]] = counters[data[j]] - 1; }

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.

Radix Sort. Anvendt til flere cifret tal fx Radix-10 til tal i Ti-tals systemet 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.

Radix Sort. Anvendt til flere cifret tal fx Radix-10 til tal i Ti-tals systemet 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.

Radix Sort. Anvendt til flere cifret tal fx Radix-10 til tal i Ti-tals systemet 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.

Radix Sort. Anvendt til flere cifret tal fx Radix-10 til tal i Ti-tals systemet 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.

Radix Sort. Anvendt til flere cifret tal fx Radix-10 til tal i Ti-tals systemet 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.

Radix Sort. Anvendt til flere cifret tal fx Radix-10 til tal i Ti-tals systemet 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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.