2. Felder (Arrays) 2.1 Suchen in Feldern. lineares Suchen: siehe Kapitel 1. Binäres Suchen. Vor.: Elemente (z.b. aufsteigend) sortiert

Transkript

1 Suchen in Feldern 2. Felder (Arrays) lineares Suchen: siehe Kapitel 1 Binäres Suchen Vor.: Elemente (z.b. aufsteigend) sortiert ( später) Idee: Divide & Conquer (teile und herrsche) public <T extends Comparable<T>> int binsearch(t v, T[] a){ int mid; int low = 0; int up = a.length-1; while (low <= up){ mid = (low + up) / 2; if (v.compareto(a[mid])<0) up = mid - 1; else if (v.compareto(a[mid])>0) low = mid + 1; else return mid;} return -1;}

2 11 Aufwand im schlechtesten Fall wenn gesuchtes Element größer als alle vorhandenen gemessen in #Vergleiche t W (1) = 4 t W (n) 3 + t W ( n/2 ) für n > 1, o.b.d.a. n = 2 k für k IN (ggf. auffüllen) t W (n) 3 log 2 n + 4 (also: t W (n) O(log n) ) Beweis (Induktion über k): k = 0 trivial k k + 1 : t W (2 k+1 ) 3 + t W (2 k ) log 2 2 k + 4 = 3 (log log 2 2 k ) + 4 = 3 log 2 (2 1 2 k ) + 4 = 3 log 2 (2 k+1 ) + 4

3 12 für n = 2 k 1, erfolgreiche Suche: t A (n) 1 n }{{} W keit, dass El. gesucht log 2 (n+1) 1 i=0 log 2 (n+1) 1 = 3 n ( i=0 2 i } {{ } geometrische Summenformel + Aufwand im Mittel 2 i }{{} # El., die nach i + 1 Iterationen erreichbar log 2 (n+1) 1 i=0 (3 + 3i) }{{} # Schritte für i + 1 Iterationen i 2 i ) } {{ } Lemma s.u. = 3 n (2log 2 (n+1) ((log 2 (n + 1) 2) 2 log 2 (n+1) + 2)) = 3 n ((n + 1 1) + (n + 1) log 2(n + 1) 2(n + 1) + 2) = 3 log 2 (n + 1) log 2 (n+1) n O(log n) also im Mittel ca. 7 Vergleiche weniger als im worst case

4 13 m 1 i=0 Lemma i 2 i = (m 2) 2 m + 2 (für m 1) Beweis: m = 1: 0 = 0 m m + 1: m+1 1 i=0 i 2 i = m 2 m + m 1 i=0 i 2 i = m 2 m + (m 2) 2 m + 2 = (2m 2) 2 m + 2 = (m 1) 2 m = (m + 1 2) 2 m+1 + 2

5 14 Lösung von Rekursionsformeln Lösung aus Ergebnissen für kleine n erahnen und per Induktion beweisen oder Computer-Algebra-System wie Maple oder Mathematica verwenden oder oft mit folgendem Satz: (Beweis s. Cormen et al.) Seien a 1 und b > 1 und f : IN IN, t(n) = a t(n/b) + f(n), dann: 1) t(n) Θ(n log b a ), falls f(n) O(n log b a ɛ ) und ɛ > 0 2) t(n) Θ(n log b a log n), falls f(n) Θ(n log b a ) 3) t(n) Θ(f(n)), falls f(n) Ω(n log b a+ɛ ) und ɛ > 0 und a f(n/b) c f(n) für ein c < 1 und genügend große n

6 Sortieren in Praxis > 1 4 der Rechenzeit für Sortieren! gegeben: Folge (hier: Array) von Datensätzen s i = (k i, d i ) i = 0,..., n 1 totale Ordnungsrelation (reflexiv, transitiv, antisymmetrisch) K K wobei i k i K gesucht: Permutation π : {0,..., n 1} {0,..., n 1} mit k π(0) k π(1)... k π(n 1) Bem.: anderes Problem: Sortieren von Dateien ( externe Sortierverfahren)

7 Naive Sortierverfahren Sortieren durch direkte Auswahl public class SelectionSort<T extends Comparable<T>> implements SortAlgorithm<T>{ } public void sort(t[] a){ for(int i = 0; i <= a.length-2; i++){ int k = i; T current = a[i]; for (int j = i+1; j <= a.length-1; j++){ if (a[j].compareto(current)<0) { k=j; current = a[j];}} a[k] = a[i]; a[i] = current;}} Beispiel: Aufwand: t W (n) = t A (n) = t B (n) = n 2 i=0 = n 1 l=1 (n i 1) l = n (n 1) 2 Θ(n 2 )

8 Sortieren durch direktes Einfügen Idee: Beispiel: n-1 Iterationen(i = 1,..., n 1) füge in Iteration i Element a[i] an der richtigen Stelle in die sortierte Teilfolge a[0],..., a[i-1] ein (hierzu größere Elemente nach rechts schieben ) Aufwand: t W (n) Θ(n 2 ), t A (n) Θ(n 2 ) Bem.: linearer Aufwand, falls Array (fast) sortiert

9 Bubblesort Idee: jedes Element wird solange mit Nachbarn verglichen und ggf. vertauscht, bis keine Änderung mehr Beispiel: 1.Iteration 2.Iteration Iteration { Aufwand: t W (n) Θ(n 2 ), t A (n) Θ(n 2 )

10 Quicksort Idee: Divide and Conquer (teile und herrsche) Folge in 2 Teilfolgen teilen, so dass elementweise Folge 1 Folge 2 Teilfolgen rekursiv sortieren

11 20 Quicksort in Java public class QuickSort <T extends Comparable<T>> implements SortAlgorithm<T>{ public void sort(t[] a){quicksort(a,0,a.length-1);} public void quicksort(t[] a, int low, int high){ if (low >= high) return; int left = low; int right = high; T pivot = a[(low+high)/2]; do { while (a[left].compareto(pivot)<0) left++; while(a[right].compareto(pivot)>0) right--; if (left <= right){ T temp = a[right]; a[right--] = a[left]; a[left++] = temp;}} while (left <= right); } if (low < right) quicksort(a,low,right); if (high > left) quicksort(a,left,high);}

12 21 Beispiel low Pivot high left right left right right left low left right high right left Abbruch

13 22 Aufwand: (in Element-Vergleichen) Aufteilungsphase: pro Vergleich wird left bzw. right um 1 verschoben n + 1 Element-Vergleiche (nicht Index-Vergleiche!) Worst Case: t W (1) = 0 t W (n) n }{{ + 1} Aufteilung + t W (n 1) für n > 1 Zeige: t W (n) n n 2 O(n2 ) für n 1 Beweis: (Induktion) n = 1: t W (1) = 0 = n n + 1 : t W (n + 1) n t W (n) n n n 2 Best Case: t B (n) O(n log n) = n2 2 + (n ) n 2 = n2 +2n n 2 = (n+1) (n + 1) 2

14 23 Verhalten im Mittel (Annahme: alle Permutationen gleich wahrscheinlich, Elemente paarweise verschieden) t A (n) = 0 für n 1 t A (n) = n n 1 n (t A(i 1) + t A (n i)) für n > 1 i=1 = n n n 1 t A (i) i=0 = n n n 1 i=1 t A (i) Zeige: t A (n) c n log 2 n O(n log 2 n) für n 1 und geeignetes c > 0 Beweis: (Induktion) Induktionsanfang: n = 1 trivial Induktionsvoraussetzung: t A (i) c i log 2 i für 1 i n 1

15 24 Induktionsschluss (1,..., n 1 n, n 2): t A (n) = n n n c n n c n ( n c n ( n 1 i=1 n 1 t A (i) i log 2 i i=1 n/2 i=1 n/2 i=1 i log 2 i + n 1 i (log 2 n 1) + i= n/2 +1 n 1 i log 2 i) i= n/2 +1 i log 2 n) (denn für i n/2 : log 2 i log 2 n/2 = log 2 n log 2 2 = log 2 n 1 für n/2 + 1 i n 1 : log 2 i log 2 n)

16 25 n c n/2 n ( i=1 i (log 2 n 1) + n 1 i= n/2 +1 i log 2 n) n c n ( n/2 ( n/2 +1) 2 (log 2 n 1) + ( n(n 1) 2 n/2 ( n/2 +1) 2 ) log 2 n) = n c n (n(n 1) 2 log 2 n n/2 ( n/2 +1) 2 ) n c n (n(n 1) 2 log 2 n (n/2 1)(n/2) 2 ) n c (n 1) log 2 n c 2 (n 2 1) = (1 c 4 ) n }{{} 0 für c c 2 c log 2 n +c n log 2 n }{{} 0 für c 2 c n log 2 n für c 4 (wähle z.b. c = 4)

17 Heapsort Idee: verwende Prioritäten-gesteuerte Warteschlange, implementiert durch Heap (Haufen) (Heapaufbau: O(n), getmax: O(log n)) entnehme die n Elemente sukzessiv aus dem Heap sortierte Reihenfolge, Aufwand: O(n log n)

18 Heap Heap ist Array ElementTyp[n] h mit: { h[i] h[2 i + 1] für i = 0,..., n/2 1 (HB) h[i] h[2 i + 2] für i = 0,..., n/2 2 Beispiel: Heap in Baumdarstellung beachte: h[0] ist Maximum! (analog: Heap mit h[0] als Minimum)

19 Aufbau eines Heaps Idee: Blätter erfüllen die Heapbedingung (HB) trivialerweise erweitere Bereich, der HB erfüllt, sukzessiv nach vorne hierzu: vertausche Element, das HB nicht erfüllt, solange mit größerem Nachfolger, bis HB erfüllt (spätestens auf Blattebene)

20 29 13 Beispiel: Heapaufbau

21 30 Heap-Aufbau in Java public class HeapSort<T extends Comparable<T>> implements SortAlgorithm<T>{ protected T[] h; public void sinke(int l, int r){ int i,j; T x; i = l; j = 2*l+1; x = h[l]; if (j<r && h[j+1].compareto(h[j])>0) j++; while (j <= r && h[j].compareto(x)>0){ h[i] = h[j]; i = j; j = 2*j+1; if (j < r && h[j+1].compareto(h[j])>0) j++;} h[i] = x;} public void baueheap(){ for(int i = h.length/2-1; i>= 0; i--) sinke(i,h.length-1);} }... getmax, sort s.u....

22 31 Vorüberlegungen zur Aufwandsberechnung Lemma: Ein vollständiger binärer Baum der Höhe h hat n = 2 h+1 1 Knoten h 0 Beweis: (Induktion über h) h = 0: trivial h h + 1: n = 2 (2 h+1 1) + 1 = 2 (h+1)+1 1 Korollar: Die Höhe eines vollständigen binären Baumes mit n Knoten ist h = log 2 (n + 1) 1 O(log n)

23 32 Aufwand im Worst Case: (in Sinkschritten) t baue W (n) tbaue W (2h+1 1) 2 h h h h = h i=0 2 h i i = }{{} ( ) zeige ( ): (durch Induktion über h) 2 h+1 h 2 O(n) h = 0: trivial h h + 1 : h+1 i=0 2 (h+1) i i = 2 0 (h + 1) + h = h h i=0 i=0 2 (h+1) i i 2 h i i = h (2 h+1 h 2) = 2 (h+1)+1 (h + 1) 2

24 Maximum aus Heap entnehmen public T getmax(int r){ T max = h[0]; h[0] = h[r]; sinke(0, r-1); return max;} Aufwand: t getmax W (n) O(log n) ( Korollar)

25 Heapsort in Java public void heapsort(t[] a){ h = a; baueheap(); for (int r = h.length-1; r>0; r--) h[r] = getmax(r);} Aufwand: t W (n) = t baue W n 1 (n) + r=1 c t getmax W (r) O(n log n) für ein c > 0

26 Mergesort Idee: sukzessives Mischen von je zwei kleinen sortierten Teilfolgen zu einer größeren (rekursiv oder iterativ) 1-elementige Folgen sind sortiert! Mischen: übernehme jeweils das nächstkleinere Element aus seiner Teilfolge in die Ergebnisfolge Beispiel: Mischen (< 1, 9, 16, 23 >, < 14, 17, 19, 28 >) < 1, 9, 14, 16, 17, 19, 23, 28 >

27 36 Mischen in Java public class MergeSort<T extends Comparable<T>> implements SortAlgorithm<T>{ public void merge(t[] a, int l1, int r1, T[] b, int l2, int r2, T[] c, int l3) { while (l1 < r1 && l2 < r2) c[l3++] = (a[l1].compareto(b[l2])<0)? a[l1++] : b[l2++]; while (l1 < r1) c[l3++] = a[l1++]; while (l2 < r2) c[l3++] = b[l2++];} public void distribute(t[] a, T[] b, T[] c, int l){... s.u....} } public void sort(t[] a){... s.u....} Aufwand: t merge W (n) O(n)

28 37 Aufteilen public void distribute(t[] a, T[] b, T[] c, int l){ int i = 0; for (int j=0; j<a.length; j += 2*l) { for (int k=j/2; k<j/2+l; k++) b[k]=a[i++]; for (int k=j/2; k<j/2+l; k++) c[k]=a[i++];}} Aufwand: t distr W (n) : keine Element-Vergleiche, O(n) Bewegungen

29 38 Mergesort in Java o.b.d.a. n = 2 k, k IN (ggfs. Auffüllen mit ) public void sort(t[] a) { // Vor.: a.length ist 2er-Potenz T[] b = a.clone(); T[] c = a.clone(); for (int size=1; size<a.length; size *=2) { distribute(a, b, c, size); for (int i=0; i<a.length/2; i+=size) merge(b, i, i+size, c, i, i+size, a, 2*i);}}

30 39 Bemerkungen Verbesserung: Verteilphase in Mischphase integrierbar Mergesort auch geeignet zum Sortieren von sequentiellen Dateien! Variante: natürliches Mischen, zufällig sortierte Teilfolgen (Läufe) ausnutzen Verbesserung (bei Dateien): n-wege-mischen weniger Durchläufe (für n > 2) Variante: Mehrphasen-Mischsortieren: leeres Band wird Ziel bei Dateien: internes Sortieren erzeugt lange Ausgangsläufe

31 40 Beispiel: Mergesort < 48, 13, 27, 56, 42, 82, 96, 69 > < 48 >, < 13 >, < 27 >, < 56 >, < 42 >, < 82 >, < 96 >, < 69 > < 13, 48 >, < 27, 56 >, < 42, 82 >, < 69, 96 > < 13, 27, 48, 56 >, < 42, 69, 82, 96 > < 13, 27, 42, 48, 56, 69, 82, 96 > Aufwand: t mergesort W (n) = log n (t distr W i=1 (n) + n t merge 2 i W (2 i )) O(n log n) }{{} O(2 i )

32 Experimentelle Untersuchung vergleichender Sortierverfahren Methode \ n direktes Einfügen 4, ,23 direkte Auswahl 2, ,36 Bubblesort 8, ,49 Heapsort 0,61 41,98 Quicksort 0,57 20,81 Mergesort 0,83 38,63 Durchschnittswerte (in ms) von 6 aktuellen Rechnern, vom Laptop bis zum High-End-PC.

33 Sortierverfahren für kleine Wertebereiche falls Schlüssel aus kleinem Wertebereich W : (o.b.d.a. W := {0,..., m 1}) Sortieren ohne Element-Vergleiche effizienter Binsort: füge jeden Schlüssel s in Liste L s ein verkette Listen Aufwand: O(n + m) = O(n) für m c n Radixsort: bei m n k Folge von k Binsorts in i-tem Binsort wird bzgl. Teilschlüssel (s/n i 1 ) mod n sortiert; i = 1,..., k Aufwand: O(k n)

34 43 Beispiel: Radixsort n = 10, m = n 2, Ausgangsfolge: 13, 27, 48, 56, 42, 82, 96, 69, 18, Binsort: (bzgl. s/1 mod n = s mod 10) nach Einfügen in Listen: L 0 : L 5 : L 1 : L 6 : 56, 96 L 2 : 42, 82 L 7 : 27, 57 L 3 : 13 L 8 : 48, 18 L 4 : L 9 : 69 wichtig: ursprüngliche Reihenfolge in Liste aufrechterhalten! nach Verketten: 42, 82, 13, 56, 96, 27, 57, 48, 18, 69

35 44 2. Binsort: (bzgl. (s/10) mod 10) nach Einfügen in Listen: L 0 : L 5 : 56, 57 L 1 : 13, 18 L 6 : 69 L 2 : 27 L 7 : L 3 : L 8 : 82 L 4 : 42, 48 L 9 : 96 nach Verketten: 13, 18, 27, 42, 48, 56, 57, 69, 82, 96

36 Untere Schranke für vergleichende Sortierverfahren keine Annahme über Wertebereich ausschließlich Schlüsselvergleiche jeder Vergleich entspricht Knoten in binärem Entscheidungsbaum jedem Knoten im Entscheidungsbaum entspricht eine Menge (noch) möglicher Permutationen der Ausgangsfolge

37 46 Aufteilung des Suchraums a b c a c b b a c b c a c a b c b a a[0]<a[1]? a b c a c b b c a a[1]<a[2]? b a c c a b c b a a[1]<a[2]? a b c a c b b c a b a c c a b c b a a[0]<a[2]? a[0]<a[2]? a c b b c a b a c c a b

38 47 Berechnung der unteren Schranke n! Permutationen n! Blätter des (binären!) Entscheidungsbaums #Vergleiche im Worst Case: h(t ) log 2 (n! + 1) 1 log 2 ( n 2 n 2 ) 1 = n 2 log 2 n 2 1 = n 2 log n n 2 1 Ω(n log n) man kann zeigen, dass auch im Mittel Ω(n log n) Vergleiche nötig sind