Sortieren. Maple sortiert; Unordnung schaffen. > restart;

Transkript

1 restart; Sortieren Maple sortiert; Unordnung schaffen Vorbemerkung: Maple kann schon selber sortieren. Dazu erzeugen wir erstmal eine unsortierte Liste: > r := rand(1..100): > l := [seq(r(), i=1..10)]; l := [ 82, 71, 98, 64, 77, 39, 86, 69, 22, 10] Die Funktion sort sortiert eine Liste: > sort(l); [ 10, 22, 39, 64, 69, 71, 77, 82, 86, 98] Für kompliziertere Fälle kann man auch eine eigene Vergleichsfunktion bauen. Hier etwa, um zweielementige Listen nach ihrem zweiten Element zu sortieren: > l := [seq([i,r()],i=1..10)]; > sort(l, (x,y)->x[2]<y[2]); l := [[ 156, ], [ 264, ], [ 358, ],[ 461, ],[ 575, ],[ 686, ],[ 717, ],[ 862, ],[ 98, ],[ 10, 50] ] [[ 98, ], [ 717, ], [ 10, 50 ], [ 156, ],[ 358, ],[ 461, ],[ 862, ],[ 264, ],[ 575, ],[ 686, ]] Das nutzen wir aus, um uns Testfälle zu erzeugen mittels einer Funktion, die eine "zufällige" Permutation der Zahlen 1..n liefert - z.b. [9,6,1,10,8,7,4,2,5,3]: > unsortiert := proc(n) local l; l := [seq([i,r()],i=1..n)]; # Sortieren nach der zweiten Komponente der l[i] l := sort(l, (x,y)->x[2]<y[2]); # Jetzt brauchen wir nur noch die ersten Komponenten der l[i] [seq(x[1],x=l)] unsortiert := proc( n) local l; l := [ seq ([ i, r ()], i = 1.. n )]; l := sort ( l, ( x, y ) x[ 2 ] < y[ 2 ]); [ seq ( x[ 1 ], x = l) ] > unsortiert(10); [ ,,,, > sort(%); 78910,,,, Eine andere Möglichkeit, dieselbe Aufgabe zu lösen: wir fangen mit der sortierten Liste l = [1,...,n] an und vertauschen für i=1..n-1 die Komponente l[i] mit einem zufällig ausgewählten l[j], j=i,...,n: > unsortiert2 := proc(n) local l,i,j,h; # option trace;

2 l := [seq(i, i=1..n)]; for i from 1 to n-1 do # für Position i Tauschindex j aus i..n auswählen j := i + (rand() mod (n+1-i)); # und vertauschen h := l[i]; l[i] := l[j]; l[j] := h end do; l unsortiert2 := proc( n) local l, i, j, h; l := [ seq ( i, i = 1.. n )]; for i to n 1 do j := i + ( rand () mod ( n + 1 i )); h := li [ ]; li [ ]:= lj [ ]; lj [ ]:= h end do; l > unsortiert2(10); [ ,,,, first und rest Wir werden (obwohl das sehr ineffizient ist) hier mit Listen arbeiten. Damit sich das besser liest, verwenden wir wieder die Hilfsfunktionen aus der Übung voriger Woche (Rösselsprung): Die Funktion first liefert das erste Element einer Liste: > first := l -> l[1]; first := l l 1 Die Funktion rest liefert den Rest (alle Elemente außer dem ersten) einer Liste (-1 ist der Index des letzten Elements): > rest := l -> l[2..-1]; Ein Test: > first([1,2,3]); > rest([1,2,3]); rest := l l [ 23, ] Beim Testen auch an die Grenzfälle denken! > first([1]); > rest([1]); 1 [] > first([]);

3 > > rest([]); Error, (in first) invalid subscript selector Error, (in rest) invalid subscript selector Wir hätten also oben schreiben müssen "... liefert... einer nichtleeren Liste...". Wir müssen bei der Verwendung dieser Funktionen drauf achten! > Erweitertes append Die Funktion append soll zwei Listen aneinanderhängen. Gegenüber letzter Woche haben wir nun einen Sonderwunsch: Dinge, die keine Liste sind, sollen als einelementige Listen behandelt werden. > append := proc(l1, l2) local s1, s2; if type(l1, list) then s1 := op(l1) s1 := l1 ; if type(l2, list) then s2 := op(l2) s2 := l2 ; [s1, s2] append := proc( l1, l2) local s1, s2; if type ( l1, list ) then s1 := op( l1 ) s1 := l1 ; if type ( l2, list ) then s2 := op( l2 ) s2 := l2 ; [ s1, s2 ] > append([1,2,3],[4,5,6]); > append(1, [2,3]); [ 123,, ] > append([1,2],3); [ 123,, ] > append(1,2); [ 12, ] Die leere Liste macht hier ausnahmsweise keine Probleme: > append(append([],[1,2]),[]); [ 12, ] Mischen Hier kommt die Prozedur merge, mit zwei sortierten Listen l1in und l2in als Parameter und der zusammengeführten sortierten Liste als Ergebnis. Vorsicht: die Listen, die wir als Aktualparameter bekommen, werden im Verlauf der Prozedur verändert, wir müssen also Kopien l1 von l1in und l2 von l2in herstellen. > merge := proc(l1in, l2in)

4 local l1, l2, s, x1, x2; s := []; l1 := l1in; l2 := l2in; while nops(l1)>0 or nops(l2)>0 do if nops(l2)>0 then if nops(l1)>0 then x1 := first(l1); x2 := first(l2); if x1<x2 then s := append(s, x1); l1 := rest(l1) s := append(s, x2); l2 := rest(l2) # l1 ist leer s := append(s, l2); l2 := [] # l2 ist leer s := append(s, l1); l1 := [] end do; return s merge := proc( l1in, l2in) local l1, l2, s, x1, x2; s := []; l1 := l1in; l2 := l2in; while 0 < nops( l1 ) or 0 < nops( l2 ) do if 0 < nops( l2 ) then if 0 < nops( l1 ) then x1 := first( l1 ); x2 := first( l2 ); if x1 < x2 then s := append ( s, x1 ); l1 := rest( l1 ) s := append ( s, x2 ); l2 := rest( l2 ) s := append ( s, l2 ); l2 := [] s := append ( s, l1 ); l1 := []

5 end do; return s > merge([1,2,3],[4,5,6]); > merge([4,5,6],[1,2,3]); > merge([1,3,5,7],[0,2,4]); [ , Um die Funktion besser zu verstehen, blockieren wir zwischendurch die Funktion append: > append_tmp := eval(append): > append := 'append': Jetzt die Beispiele wiederholen, dann append wieder aktivieren: > append := eval(append_tmp): Mischen: rekursive Variante Hier noch eine rekursive Lösung für das gleiche Problem: > merge_rek := proc(l1, l2) if l1=[] then l2 elif l2=[] then l1 elif first(l1)<first(l2) then append(first(l1), merge_rek(rest(l1), l2)) append(first(l2), merge_rek(l1, rest(l2))) merge_rek := proc( l1, l2) if l1 = [] then l2 elif l2 = [] then l1 elif first( l1 ) < first( l2 ) then append ( first( l1 ), merge_rek ( rest( l1), l2 )) append ( first( l2 ), merge_rek ( l1, rest( l2 ))) > merge_rek([1,2,3],[4,5,6]); > merge_rek([4,5,6],[1,2,3]); > merge_rek([1,3,5,7],[0,2,4]); [ ,

6 Auch hier lohnt sich das Experiment mit dem blockierten append: > append_tmp := eval(append): > append := 'append': Jetzt die Beispiele wiederholen, dann append wieder aktivieren: > append := eval(append_tmp): Diese Variante lässt sich auch in der funktionalen Notation hinschreiben: > merge_rek_f := (l1,l2) -> `if`(l1=[], l2, `if`(l2=[], l1, `if`(first(l1)<first(l2), append(first(l1), merge_rek_f(rest(l1), l2)), append(first(l2), merge_rek_f(l1, rest(l2))) ) ) ); merge_rek_f := ( l1, l2 ) `if` ( l1 = []l2,, `if` ( l2 = []l1,, `if` ( first( l1 ) < first( l2 ), append ( first( l1 ), merge_rek_f ( rest( l1 ), l2 )), append ( first( l2 ), merge_rek_f ( l1, rest( l2 ))) ))) > merge_rek_f([1,2,3],[4,5,6]); > merge_rek_f([4,5,6],[1,2,3]); > merge_rek_f([1,3,5,7],[0,2,4]); [ , Mergesort Wer mischen kann, kann auch sortieren: > mergesort := proc(l) local n,mitte; n := nops(l); if n=1 then l mitte := round(n/2); merge(mergesort(l[1..mitte]), mergesort(l[mitte+1..-1])) mergesort := proc( l) local n, mitte; n := nops( l ); if n = 1 then l

7 mitte := round( 1 / 2 n ); merge ( mergesort ( l [ 1.. mitte ]), mergesort ( l [ mitte ])) Es scheint zu funktionieren: > mergesort(unsortiert(100)); ,,,,,,,,,,,,,,,,,,,,,,,,,,, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100] Mehr Einsicht in den Ablauf des Programms bekommt man, indem man diesmal merge blockiert: > merge_tmp := eval(merge): > merge := 'merge'; merge := merge > mergesort([seq(i,i=1..7)]); merge ( merge ( merge ([ 1 ], [ 2 ]), merge ([ 3 ], [ 4 ])), merge ( merge ([ 5 ], [ 6 ]), [ 7] )) > merge := eval(merge_tmp): Zeitmessung Sehen wir noch nach, wie lange wir eigentlich zum Sortieren brauchen. Die Funktion time misst die Zeit, die für die Auswertung ihres Parameters benötigt wird (in Sekunden): > time(mergesort(unsortiert(2^5))); Für eine bessere Messung führen wir das Sortieren (ohne Sinn und Verstand) öfter aus: > mergesort_m := proc(l,m) local i; for i to m do mergesort(l) end do mergesort_m := proc( l, m) local i; for i to m do mergesort( l) end do Eine Beispielliste: > l := unsortiert(1000): Wenigstens in etwa wächst die Zeit proportional zur Zahl der Sortiervorgänge: > time(mergesort_m(l,1)); > time(mergesort_m(l,10))/10; > time(mergesort_m(l,50))/50; Jetzt probieren wir das für verschieden lange Listen (100 Wiederholungen):

8 > > > for k to 10 do l := unsortiert(2^k); print([2^k,time(mergesort_m(l,100))/100]) end do: [ 2, ] [ 4, ] [ 8, ] [ 16, ] [ 32, ] [ 64, ] [ 128, ] [ 256, ] [ 512, ] [ 1024, ] Der positive Aspekt ist, dass die Zeiten bei Verdoppeln der Länge nicht um einen Faktor 4 (wie bei n 2 ) steigen, sondern nur wenig mehr als um einen Faktor 2. Der direkte Vergleich mit der Konkurrenz ist allerdings deprimierend: > sort_m := proc(l,m) local i; for i to m do sort(l) end do sort_m := proc( l, m) local i; for i to m do sort( l ) end do > for k to 10 do l := unsortiert(2^k); print([2^k,time(sort_m(l,100))/100]) end do: [ 20., ] [ 40., ] [ 80., ] [ 16, 0. ] [ 32, 0. ] [ 64, 0. ] [ 128, ] [ 256, ] [ 512, ] [ 1024, ]