Sortieren DNA-Array oder DNA-Chip

Transkript

1 Sortiere DNA-Array oder DNA-Chip Jeder Pukt des Feldes repräsetiert ei Ge g i des Mesche. Ei Ge ist der Baupla eies molekulare Bausteis useres Körpers. Mittels eies DNA-Chips ka ma gleichzeitig für viele Gee () messe, i welchem Maße bestimmte Bausteie useres Körpers zu eiem bestimmte Zeitpukt produziert werde (welche Gee i welchem Maße exprimiert werde). Mittels dieser Chips ka ma zum Beispiel die Ge-Expressio verschiedeer Zellkulture (Tumorzelle mit ormale Zelle) miteiader vergleiche: Gee, die stärker i der erste Zellart exprimiert werde, leuchte itesiv rot. Gee, die stärker i der zweite Zellart exprimiert werde, leuchte itesiv grü. Die Differez a[i] der Ge-Expressio eies Ges g i i de beide Zellarte ka ma i Form eier reelle Zahl agebe: a[i] [-,] für alle i,,..., -. Aufgabe: Sortiere die Gee aufsteiged ach de Werte der Differeze a[i]. Sortiere Gegebe ei Feld a der Größe mit reelle Zahle a[i], i,,...,. Sortiere die Zahle i aufsteigeder Reihefolge. Nach dem Sortiere gilt: a[] a[] a[]... a[-] Allgemeie Formulierug des Sortier-Problems: Gegebe eie Mege A vo Elemete aus eiem Uiversum U, auf dem es eie Ordugsrelatio gibt. Sortiere die Elemete der Mege A i aufsteigeder (falleder) Reihefolge bezüglich der Ordugsrelatio. Beispiel : Uiversum U die Mege aller eglische Wörter Ordugsrelatio lexikographische Ordug für Strigs Beispiel : Uiversum U die Mege aller Studete der Uiversität. Ordugsrelatio Matrikelummer Wir werde im folgede Abschitt verschiedee Sortier-Verfahre kee lere ud dabei eiige Problemlösestrategie diskutiere.

2 Divide & Coquer 3 Problem T() Kokateatio ( Problem B(), Problem T(-) ) B() Bereche das Miimum vo Zahle T( ) c d + c + T( ) k Ei triviales Sortierverfahre it idex_of_miimum(it [ ] a, it mi_idex, it max_idex) { it idex mi_idex; for (it i mi_idex; i < max_idex ; i++) if (a[idex] a[i]) idex i; retur idex; Die obige Fuktio sucht im Teilfeld vo Feld a zwische dem Idex mi_idex ud max_idex ach der Feldkompoete, die die kleiste Zahl ethält, ud gibt dere Idex zurück. Mit Hilfe dieser Fuktio köe wir a wie folgt sortiere: void trivial_sort(it [ ] a, it size_of_a) { for (it i ; i < size_of_a ; i++) { it j idex_of_miimum(a, i, size_of_a); // Suche ächstes Mi. it k a[ i ]; // Zwischespeicherug a[i] a[ i ] a[ j ]; // die ächste sortierte Zahl a[ j ] k;

3 Ei triviales Sortierverfahre k Der Zeitaufwad für die for-schleife im i-te Schritt ist gleich c( i) wobei c eie Kostate ist ud (size_of_a) die Größe des Feldes a. 5 Die Gesamtlaufzeit vo trivial_sort ist daher: c i ( i) c( i) c( i i ) c + Θ( ) Satz []: Die (worst-case) Laufzeit vo trivial_sort ist i Θ( ), wobei die Größe der Eigabe (Größe des Feldes) ist. HeapSort 6 Ei Heap ist ei biärer Baum mit de folgede Eigeschafte: [] Für jede Kote v des Heaps mit eiem Vater v.paret (! NULL) gilt: v.key v.paret-key [] Der Heap wird begied mit der Wurzel i eier bestimmte Reihefolge (möglichst weit obe ud soweit liks wie möglich) Schicht für Schicht aufgefüllt (siehe Abbildug ute liks, die Zahle gebe die Reihefolge a): usw Durch das Eiführe eies eue Elemets (a der richtige Positio) ka die Heap-Eigeschaft verletzt werde. 3

4 HeapSort 7 Wir ehme a, dass v ei Zeiger auf eie (de eigefügte) Kote ist. Die Reparatur erfolgt durch Hochschiebe des eue Kotes v, d.h., solage v-key < v-paret-key vertauscht ma Vater ud Soh: it help v-key; v-key v-paret-key; v-paret-key help; v v-paret; HeapSort Aufgrud der Reihefolge der Eifüguge hat ei Heap mit Elemete Höhe log(). Da ma bei jeder Eifügug höchstes de Pfad vom Eifüge- Kote bis zur Wurzel wadert ud dabei pro Kote ur kostate Zeit beötigt, hat jede Eifüge-Operatio im schlimmste Fall Laufzeit O(log ). Ei Heap mit Elemete ka daher i Zeit O( log ) aufgebaut werde. Das kleiste Elemet i eiem Heap ist i der Wurzel gespeichert. Mit Hilfe eies Heaps ka ma u die Elemete wie folgt sortiere: Solage der Heap icht leer ist, führt ma die folgede Operatioe aus: Etehme das Elemet i der Wurzel ud speichere es am Ede des Feldes der bereits sortierte Elemete Bewege das zuletzt eigefügte Elemet i die Wurzel. Schiebe das Elemet solage ach ute, bis die Heap-Eigeschaft wiederhergestellt ist usw. 4

5 9 HeapSort Wie bewege wir die i der Wurzel eigefügte Elemete auf ihre Platz? Wir simuliere de Heap mit eiem Feld a[,-]: a[] void shift_dow( it [ ] a, it i, it last) { bool fiished false; a[] a[] it k ; a[3] a[4] a[5] a[6] while (!fiished) { if ((*i+) < last) { a[7] a[8] usw. if (a[*i+] < a[*i+]) k *i+; else k *i+; Das like Kid des Kotes else if ((*i+) < last) k *i+; mit Idex i hat de Idex i +. else retur; Das rechte Kid des Kotes if (a[ i ] a[ k ]) { mit Idex i hat de Idex i +. it help a[ i ]; a[ i ] a[ k ]; a[ k ] help; i k; else fiished true; HeapSort Wie mache wir aus dem Feld eie Heap? Wir simuliere de Heap mit eiem Feld a[,-]: a[] a[] a[] a[3] a[4] a[5] a[6] a[7] a[8] usw. void heapify( it [ ] a, it size_of_a) { // macht eie Heap aus Feld a for (it i size_of_a - ; i ; i--) shift_dow(a, i, size_of_a); Die obige Fuktio baut eie Heap, i dem sie Baumschicht für Baumschicht die Heap-Eigeschaft herstellt. Hierbei begie wir mit der uterste Schicht. 5

6 HeapSort Wie sortiere wir mit eiem Heap (Feld)? O.B.d.A sortiere wir die Zahle im Feld falled (das letzte Elemet ist das kleiste): help usw. void heap_sort( it [ ] a, it size_of_a) { // Sortiert das Feld a heapify(a, size_of_a); // Baue de Heap for (it i size_of_a - ; i ; i--) { it help a[i]; // Rette de Schlüssel vo a[i] a[ i ] a[]; // ei weiteres Elemet sortiert a[] help; // euer Schlüssel für die Wurzel shift_dow(a,, i); // Reparatur der Heap-Eigesch. HeapSort Satz [3]: Heap-Sort sortiert ei Feld mit Elemete i Zeit O( log ). Beweis: Der Aufbau des Heaps heapify hat eie Laufzeit vo O( log ). Jede Iteratio i der for -Schleife hat im worst-case Laufzeit O(log ), wobei wir i jedem Durchgag ei Elemet eisortiere. 6

7 Divide & Coquer 3 Idee. Zerlege das ursprügliche Problem der Größe i kleiere Teilprobleme.. Ma löse die Teilprobleme ud 3. setze die Gesamtlösug aus de Lösuge der Teilprobleme zusamme. Zum Beispiel köte wir das Problem der Größe i zwei Teilprobleme der Größe / zerlege. T()? (T(/), T(/)) MergeSort 4 T() Merge (T(/), T(/)) Frage : Wie köe wir das Sortierproblem zerlege? Wir zerlege das Feld i zwei Teilfelder der Läge (ugefähr) /! Frage : Nehme wir a, dass die beide Teilfelder sortiert sid? Wie köe wir aus de Teillösuge die Gesamtlösug effiziet bereche? Ma mische die sortierte Halbfelder zu dem sortierte Feld!

8 MergeSort 5 void merge(it [ ] a, it s, it e, it s, it e) { it b ew it[e-s+]; // Speicherplatz für sortierte Folge it i s, j s, k ; // Idexzähler for ( ; i < e && j < e ; k++ ) { if (a[i] < a[j]) { b[k] a[i]; i++; else { b[k] a[j]; j++; for ( ; i < e; k++,i++) b[k] a[i]; // Leere de Rest des erstes Teilfelds for ( ; j < e; k++,j++) b[k] a[j]; // Leere de Rest des zweite Teilfelds for ( k, i s ; i < e; i++,k++) a[i] b[k]; // Kopiere sortierte Folge Ma mische die sortierte Halbfelder zu dem sortierte Feld! MergeSort 6 void merge(it [ ] a, it s, it e, it s, it e) { it b ew it[e-s+]; // Speicherplatz für sortierte Folge it i s, j s, k ; // Idexzähler for ( ; i < e && j < e ; k++ ) { if (a[i] < a[j]) { b[k] a[i]; i++; else { b[k] a[j]; j++; for ( ; i < e; k++,i++) b[k] a[i]; // Leere de Rest des erstes Teilfelds for ( ; j < e; k++,j++) b[k] a[j]; // Leere de Rest des zweite Teilfelds for ( k, i s ; i < e; i++,k++) a[i] b[k]; // Kopiere sortierte Folge Uter der Aahme, dass die beide Teilfelder a[s,e] ud a[s,e] bereits (korrekt) sortiert sid, folgt die Korrektheit des Algorithmus merge aus der Tatsache, dass die Idizes i ud j jeweils die kleiste och icht i b eisortierte Elemete der beide Teilfelder repräsetiere ud dass das Miimum dieser beide Zahle folglich die kleiste och icht verarbeitete Zahl des Rests sei muss. Die Laufzeit vo merge für zwei Teilfelder der Läge / ist Θ(). 8

9 MergeSort 7 void merge_sort(it [ ] a, it mi, it max) { if (max-mi ) { // Gibt es was zu tu? merge_sort(a, mi, mi + ((max-mi)/)); // Sortiere das erste Teilfeld merge_sort(a, mi +((max-mi)/) +, max); // Sortiere das zweite Teilfeld merge(a, mi, mi + ((max-mi)/), mi + ((max-mi)/) +, max); Laufzeit des Algorithmus merge_sort für ei Feld der Größe : Satz []: T () c T ( ) T ( ) + d T ( ) 4T ( ) + d + d 4 log T ( ) T () + d log c + d log Θ( log ) Die Laufzeit des MergeSort-Algorithmus für ei Feld der Größe ist Θ( log ). QuickSort 8 Idee: Ma wähle zufällig ei Elemet e aus de Elemete der Mege E ud ma vergleiche alle adere Elemete mit e. Mit Hilfe dieser Vergleiche zerlegt ma E i zwei Teilmege: E e mit Schlüssel kleier gleich dem Schlüssel vo e. E e mit Schlüssel größer dem Schlüssel vo e. Ma führe rekursiv die gleiche Prozedur für E e ud E e aus. QS(E) Vergleich(E\e, e) + QS(E e ) + QS(E e ) 9

10 QuickSort 9 Die Zahl der Elemete i de beide Mege E e, E e hägt atürlich vo e ab. We ma (städig) Pech hat (im worst case), ist eie der Mege immer leer, z.b. E e, ud der Algorithmus hat die gleiche Komplexität (O( )) wie Isertio_Sort ud trivial_sort. Falls ma immer durch die Wahl vo e zwei ugefähr gleich mächtige Mege produziert, da erhält ma als Laufzeit: QS() QS(/) + c O( log ) QuickSort L L L L R R R R e Pivot-Elemet

11 QuickSort void quick_sort(it [ ] a, it start, it ed) { it legth ed - start +; if( legth ) { it L start; it R ed; it e a[l]; // wir wähle e als die erste Zahl im Feld it temp a[r]; while (L < R) { if (temp < e) { a[l] temp; L++; temp a[l]; else { a[r] temp; R-- ; temp a[r] a[l] e; if ( (L-) start) quick_sort(a, start, L-); if ((R+) < ed) quick_sort(a, R+, ed); L R e temp QuickSort void quick_sort(it [ ] a, it start, it ed) { it legth ed - start +; if( legth ) { it L start; it R ed; it e a[l]; // wir wähle e als die erste Zahl im Feld it temp a[r]; while (L < R) { if (temp < e) { a[l] temp; L++; temp a[l]; else { a[r] temp; R-- ; temp a[r] a[l] e; if ( (L-) start) quick_sort(a, start, L-); if ((R+) < ed) quick_sort(a, R+, ed); Die Laufzeit vo QuickSort ist proportioal zur Zahl der Vergleiche zweier Feldelemete, die i der while-schleife vo alle rekursive Aufrufe ausgeführt werde. Ma beachte, dass jedes Paar vo Feldelemete höchstes eimal vergliche wird.

12 QuickSort Der Eifachheit halber beee wir die Feldelemete i a um: z < z <... < z so dass z i das i-t kleiste Elemet ist. 3 Ferer bezeiche wir mit Z ij die folgede Mege vo Feldelemete: Z ij { z i, z i+,..., z j Usere Aalyse basiert wieder auf der Utersuchug vo Zufallsvariable: X ij falls z i ud z j miteiader vergliche werde sost Die Zahl der Vergleiche X ist gleich X X ij i j i+ Daher ist die erwartete Zahl E[X] vo Vergleiche (Laufzeit) gleich E[ X ] E X ij E [ X ij ] p({ X ij ) i j i+ i j i+ i j i+ QuickSort 4 p( {X ij ) p( z i wird mit z j vergliche) Sei e das erste Pivot-Elemet das aus der Mege Z ij { z i, z i+,..., z j gewählt wird:. Ist e z i oder z j, so werde z i oder z j miteiader vergliche.. Ist e aus der Mege Z i+, j-, da gilt für die etstehede Teilmege. Eie der beide Teilmege, die durch de Vergleich mit dem Pivot-Elemet e gebildet werde, ethält z i ud die adere z j, d.h., z i ud z j werde icht miteiader vergliche.

13 QuickSort 5 p({x ij ) p( z i wird mit z j vergliche) p( z i oder z j wird als erstes Pivot-E. aus Z ij gewählt) p( z i wird als erstes Pivot-Elemet aus Z ij gewählt) + p( z j wird als erstes Pivot-Elemet aus Z ij gewählt) Jedes Elemet vo Z ij wird mit gleicher WSK als erstes gezoge! p({ X ij ) + j i + j i + j i + E[ X ] i j i+ p({ QuickSort X ij ) i j i+ j i + Wir führe eie eue Idex k j - i i die obige Gleichug ei: E i [ X ] < i k k + c i i k k < log O( log ) i c log 6 Satz [4]: Die erwartete Laufzeit vo QuickSort für Elemete ist O( log ). Beweis: (siehe obe). 3

14 BucketSort 7 Wir betrachte jetzt de Fall, dass alle Schlüssel aus eiem bestimmte Itervall [a,b[ der reelle Zahle stamme ud uiform verteilt sid. Uiforme Verteilug: Für jede Zahl z [a,b[ aus der vorgegebee Mege gilt: Die WSK, dass z aus eiem bestimmte Teilitervall [c,d[ vo [a,b[ ist, ist p( z [ c, d[) d c b a Der Eifachheit halber ehme wir o.b.d.a. a, dass die Zahle aus dem Itervall [,[ stamme. Da gilt für die obige Wahrscheilichkeit: p( z [ c, d[) d c Für c i/ ud d (i+)/ folgt also: i i + p z, für alle i {,,..., -. BucketSort 8 Idee vo BucketSort. Teile das Itervall [,[ i gleich große Itervalle, die Buckets.. Orde die Schlüssel ihre Buckets zu. 3. Sortiere die Elemete i de Buckets (Isertio_Sort). 4. Gehe durch der Buckets ud häge alle sortierte Liste zusamme. Aufgrud der uiforme Verteilug sollte die Elemete gleichmäßig über alle Buckets verteilt sei. 4

15 BucketSort 9 Eie geeigete Datestruktur für Bucket-Sort wäre zum Beispiel ei Feld B der Größe, wobei jedes Feldelemet eie Zeiger auf eie Liste vo Elemete ethält:.78 NULL.7..7 NULL A B NULL NULL..3.6 NULL.39 NULL...3 NULL.68 NULL.7.78 NULL NULL Das Feldelemet B[i] ethält eie Zeiger auf die Liste mit de Zahle im Itervall i i +, BucketSort Sei i die Zahl der im Bucket i gespeicherte Elemete. Die Laufzeit vo Bucket-Sort wird durch die folgede Rekursiosgleichug gegebe ( size_of_a): + T ( ) c d i Die erwartete Laufzeit ist folglich: i [ ( ) ] E c + di E[ c] + d E T i c + d i E i E[ [ i i ] Auf der folgede Folie zeige wir, dass E[ i ] / ist. Hieraus folgt: E [ T ) ] c + d d ( O() ] 3 5

16 BucketSort 3 Wir führe die folgede Zufallsvariable (Idikatorvariable) ei: X ij falls a[j] Bucket b[i] zugeordet wird sost für i,,..., - ud j,,..., - Es gilt: i X ij j Hieraus folgt: ächste Seite BucketSort 3 E[ E j i ] X ij E E + X ij X j j k k j j E[ X ij ] + j k k j j k ij X ik E[ X X X ij ik ij X ik ] E[ X ij ] * + *( ) ächste Seite 6

17 7 33 BucketSort + ] [ ] [ j j j k k ik ij i X X E E + ] [ ] [ j j j k k ij X ik E X E Da k j, sid die Zufallsvariable X ij ud X ik uabhägig + j j j k k ) ( BucketSort Satz [5]: Uter der Aahme, dass die Schlüssel der zu sortierede Elemete reelle Zahle aus eiem Itervall [a,b[ sid, welche uiform verteilt sid, ka ma mit BucketSort die Elemete i erwarteter Zeit O() sortiere.

18 Utere Schrake für das Sortiere 35 Die O( log ) Sortierverfahre, die wir i diesem Abschitt kee gelert habe, basiere alle auf Vergleiche vo Schlüssel. Beim vergleichede Sortiere verwede wir ur Vergleiche vo Elemete, um die Ordug der Eigabemege (a[]a, a[]a,..., a[-]a - ) zu bereche: Geauer: Gegebe zwei Elemete (die Schlüssel zweier Elemete) a i ud a j. Wir führe eietest a i < a j, a i a j, a i a j, a i a j oder a i a j aus. Wir ehme i diesem Abschitt a, dass alle Schlüssel verschiede sid, d.h., Vergleiche der Form a i a j sid icht erforderlich. Utere Schrake für das Sortiere 36 Das Etscheidugsbaummodell Der Ablauf vo vergleichede Sortierverfahre ka mittels Etscheidugsbäume abstrakt dargestellt werde. Ei Etscheidugsbaum ist ei biärer Baum, der alle mögliche Folge vo Vergleiche eies vergleichede Sortier-Algorithmus für alle mögliche Eigabemege eier bestimmte Größe repräsetiert. Alle adere Aspekte des Algorithmus werde igoriert. 8

19 Falls das Erste kleier gleich dem Zweite Utere Schrake für das Sortiere : Vergleiche das erste ud das zweite Eigabeelemet 37 :3 :3 (,,3) :3 (,,3) :3 (,3,) (3,,) (,3,) (3,,) Das Beispiel zeigt eie Etscheidugsbaum für ei triviales Sortierverfahre mit drei Elemete. Die Kotebeschriftug i:j zeigt a, dass das i-te Elemet mit dem j-te Elemet vergliche werde soll. Je achdem, wie der Vergleich edet, folgt ma der etsprechede Kate (zum ächste Vergleich oder zum Resultat des Sortiervorgags). Die Blätter repräsetiere die sortierte Folge (Permutatioe) der Eigabeelemete: (π(), π(),..., π(-)) so dass a π() < a π() <... < a π(-) Falls das Erste kleier gleich dem Zweite Utere Schrake für das Sortiere : Vergleiche das erste ud das zweite Eigabelemet 38 :3 :3 (,,3) :3 (,,3) :3 (,3,) (3,,) (,3,) (3,,) Da jeder korrekte Sortier-Algorithmus i der Lage sei muss, jede Permutatio der Eigabeelemete zu produziere, so muss der Etscheidugsbaum eies solche Algorithmus für die Problemgröße über! Blätter verfüge. Jedes dieser Blätter muss vo der Wurzel aus durch eie etsprechede Pfad erreichbar sei, der zu eier tatsächliche Ausführug des Algorithmus auf eier etsprechede Eigabemege korrespodiert. 9

20 Falls das Erste kleier gleich dem Zweite Utere Schrake für das Sortiere : Vergleiche das erste ud das zweite Eigabelemet 39 :3 :3 (,,3) :3 (,,3) :3 (,3,) (3,,) (,3,) (3,,) Die Läge des lägste Pfades vo der Wurzel des Etscheidugsbaumes zu irged eiem Blatt repräsetiert die Zahl der Vergleiche im worst-case (die worst-case Laufzeit) des Sortier-Algorithmus für die etsprechede Problemgröße. Daher etspricht die Höhe des Baumes der worse-case Performaz des etsprechede Algorithmus. Folglich ist eie utere Schrake für die Höhe aller mögliche Etscheidugsbäume, i dee jede Permutatio als ei Blatt erscheit, auch eie utere Schrake für die Laufzeit vo Sortier-Verfahre, die auf Vergleiche basiere. Satz [6]: Utere Schrake für das Sortiere Jeder vergleichede Sortier-Algorithmus beötigt im worst-case Ω( log ) Vergleiche. Beweis: Ei biärer Baum der Höhe h hat höchstes h Blätter. Jeder potetielle Etscheidugsbaum für vergleichedes Sortiere vo Elemete hat geau! Blätter. Folglich gilt für die Höhe jedes Etscheidugsbaumes: h! Durch Awedug des Logarithmus zur Basis erhalte wir: h log(!) Aus der Stirlig-Formel α! π e mit < α < folgt: e + log(!) log(π ) + log( ) + log( e) α log( ) e e log( ) log( e) log( ) log( ) log( ) Für alle mit log() log(e) gilt h Ω( log( )) 4

21 Satz [7]: Utere Schrake für das Sortiere Heap-Sort ud Merge-Sort sid asymptotisch optimale vergleichede Sortierverfahre. Beweis: Die obere Schrake vo O( log ) für die Laufzeit der Algorithme stimmt überei mit der utere Schrake vo Ω( log ) für vergleichede Sortierverfahre. 4