commit d14beceeef44463c66378456739c3deea5eb4ca4 Author: kreativmonkey Date: Wed Nov 8 12:10:16 2017 +0100 Zusammenfassung Freigeben diff --git a/Grundlagen der Informatik.apkg b/Grundlagen der Informatik.apkg new file mode 100644 index 0000000..216b3a9 Binary files /dev/null and b/Grundlagen der Informatik.apkg differ diff --git a/Karteikarten-Anki2 Grundlagen der Informatik.txt b/Karteikarten-Anki2 Grundlagen der Informatik.txt new file mode 100644 index 0000000..31dfc2e --- /dev/null +++ b/Karteikarten-Anki2 Grundlagen der Informatik.txt @@ -0,0 +1,18 @@ +Nenne die Charakteristika eines Algorithmuses Finitheit, Detterminismus, Determiniertheit und desweiteren Platzkomplexität und Terminiertheit (Zeitkomplexität) Grundlagen +Was bedeutet Finitheit eines Algorithmuses? Die Vorschrift ist mit endlichen Mitteln beschreiben. Grundlagen +Was bedeutet Detterminismus bei Algorithmen? Es ist immer eindeutig definiert, welche Regel in der Vorschrift als nächstes anzuwenden ist. Grundlagen +Was bedeutet Determiniertheit bei Algorithmen? Die Ausgabe ist immer eindeutig bestimmt. Grundlagen +Beschreibe die Platzkomplexität eines Algorithmuses? Das Verfahren darf zu jedem Zeitpunkt nur angemessen viel Speicherplatz benötigen. Grundlagen +Was versteht man unter Zeitkomplexität (Terminiertheit) bei Algorithmen? Das Verfahren sollte zu einem angemessenen Zeitpunkt terminieren. Grundlagen +Wie funktioniert QuickSort? Teile die Liste durch 2 und nehme das Element in der Mitte als Pivotelement. Lege zwei neue Listen (Liste1 und Liste2) an. Nun Sortiere die Elemente der Liste die kleiner/gleich dem Pivotelement sind in die Liste1 und alle die größer dem Pivotelement sind in Liste2. Wiederhole diesen Vorgang für jede Liste bis die Liste nur noch aus einem Element besteht. Nun füge die Listen wieder zusammen. Welchen Suchalgorithmus wird beschrieben? Grundlagen +Was ist die Binärzahl 1101 in Hexadezimal? D Wichtig +Mit welchem Verfahren rechnet man Binärzahlen in Hexadezimalzahlen um? Durch das Aufteilen der Binärzahl von hinten in 4er Packete und das Umrechnen in ihren Dezimalwert lässt sie sich in eine Hexadezimalzahl umwandeln. Wichtig +Welchen Wert hat die Dezimalzahl 11 in Hexadezimal? B Wichtig +Weg zur Umrechnung von Dezimalzahlen in Binärzahlen? Durch das teilen mit Rest durch 2 bis man bei 0 angelangt ist. Die Binärzahl ist nun der Rest der Teilungen rückwärts aufgeschrieben. Wichtig +Welcher Datentyp bildet ganze Zahlen ab? int, Integer Wichtig +Welcher Datentyp beinhaltet logische Werte? boolean Wichtig +Welche Werte nimmt boolean an? logische Werte, true und false. Wichtig +Wie lautet die Definizion von Informatik? Informatik ist die Wissenschaft, die sich mit den theoretischen Grundlagen, den Mitteln und Methoden sowie mit der Anwendung der elektronischen Datenverarbeitung beschäftigt, das heißt mit der Informationsverarbeitung unter Einsatz von Computern. Wichtig +Beschreibe den Aufbau einer Turing Maschine "1. Ein Band mit beliebig vielen Speicherstellen
2. Einem Lese/Schreibkopf um diese Speicherstellen auszulesen, zu löschen, zu beschreiben oder so zu belassen.
3. Der Lese/Schreibkopf kann um eine Stelle nach links oder rechts rücken oder stehen bleiben.
4. Schreiben kann der Kopf ein Alphabet aus endlich vielen Zeichen, zu denen immer das Leerzeichen ""Blank"" gehören muss.
5. Das Alphateb hängt vom jeweiligen Programm der Turing-Maschine ab.
6. Das Programm wird durch Anweisungen und verschiedene Zustände der Maschine beschrieben.
" Wichtig +"Nenne Algorithmen die nach dem Prinzip ""teile und herrsche"" funktionieren." QuickSort und MergeSort Wichtig +Beschreibe den Ablauf des Boyer-Moore-Matching 1. String S in dem das Pattern P gesucht wird.
2. Man vergelicht die letzte Stelle von P mit der gleichen Position in S.
3. Stimmen beide überein überprüft man die stellen davor.
4. Gibt es keine Übereinstimmung dann kontrolliert man ob die letzte übereinstimmende stelle mit irgendeiner der übrigen in P übereinstimmt.
5. Man verschiebt P bis zu dieser Stelle oder um die länge von P und beginnt von vorne.
Wichtig \ No newline at end of file diff --git a/zusammenfassung.md b/zusammenfassung.md new file mode 100644 index 0000000..168fa85 --- /dev/null +++ b/zusammenfassung.md @@ -0,0 +1,516 @@ +# Einführung + +**Definition Informatik:** +> Informatik ist die Wissenschaft, die sich mit den theoretischen Grundlagen, den Mitteln und Methoden sowie mit der Anwendung der elektronischen Datenverarbeitung beschäftigt, das heißt mit der Informationsverarbeitung unter Einsatz von Computern. + +## EVA-Prinzip + +> Die Datenverarbeitung verläuft in aller Regel nach dem EVA-Prinzip, das heißt nach dem Prinzip Eingabe $\rightarrow$ Verarbeitung $\rightarrow$ Ausgabe, oder in englischer Sprache Input $\rightarrow$ Process $\rightarrow$ Output, weshalb man auch vom IPO-Prinzip spricht. + + +# Datentypen + +| Bemerkung | Datenstruktur | +|:---------------------|:------------------------------| +| int, Integer | ganze Zahlen | +| float, real | reele Zahlen | +| boolean | logische Werte | +| String, Char, Char[] | Zeichen, Zeichenketten | +| statisch | Array, Verbund | +| dynamisch | Stack, Queue, verkettte Liste | +| partiell geordnet | Heap | + +# Zahlensysteme + +## Umrechnung von Dezimalzahlen +Ein einfacher Weg eine Dezimalzahl in eine Binär, Okta oder Hexadezimalzahl um zu wandeln ist es, die Dezimalzahl durch die Basis des neuen Zahlensystems mit Rest zu teilen. Anschließend wird der Rest von der Letzten Teilung zur ersten im neuen Zahlensystem notiert. Ein beispiel hierzu findest du unter Umrechnung \lable(Dezimalzahl zu Dualzahl). + +## Binärzahlen (Dualzahlen) + +### Umrechnung Dualzahl zu Dezimalzahl +Umrechnung Dualzahl zu Dezimalzahl: +> Eine (n + 1)-stellige Dualzahl oder auch Binärzahl ist eine Folge von n + 1 Ziffern +${a}^{n} {a}^{n-1}\cdots {a}^{1} {a}^{0}$, +die alle entweder gleich 0 oder gleich 1 sind. Der dezimale Wert dieser Zahl beträgt +${a}^{n} \cdot {2}^{n} + {a}^{n−1} \cdot {2}^{n-1} + \cdots + {a}^{1} \cdot 2 + {a}^{0}$ + +${101010}_{2}=1 \cdot {2}^{5} + 0 \cdot {2}^{4} + 1 \cdot {2}^{3} + 0 \cdot {2}^{2} + 1 \cdot {2}^{1} + 0 \cdot {2}^{0} = 32 + 8 + 2 = 42$ + +### Umrechnung Dezimalzahl zu Dualzahl +Umrechnung Dezimalzahl zu Dualzahl mit Hilfe des Teilens mit Rest der gegebenen Dezimalzahl: +Gegeben sei die Zahl 157 so wird diese durch 2 geteilt und der Rest notiert. Das ergebnis der +Division wird dann wieder durch 2 geteilt bis man bei 0 angelangt ist. + +157 : 2 = 78 Rest 1 +78 : 2 = 39 Rest 0 +39 : 2 = 19 Rest 1 +19 : 2 = 9 Rest 1 +9 : 2 = 4 Rest 1 +4 : 2 = 2 Rest 0 +2 : 2 = 1 Rest 0 +1 : 2 = 0 Rest 1 + +Der rest wird nun in umgekehrtet Reihenfolge notiert und bildet so die Binärzahl ${10011101}_{2}$. + +### Addition und Subtraktion Dualzahlen + +| | + | = | Übertrag | +|:--|:--|:--|:---------| +| 0 | 0 | 0 | 0 | +| 0 | 1 | 1 | 0 | +| 1 | 0 | 1 | 0 | +| 1 | 1 | 0 | 1 | + +| | - | = | Übertrag | +|:--|:--|:--|:---------| +| 0 | 0 | 0 | 0 | +| 1 | 0 | 1 | 0 | +| 1 | 1 | 0 | 0 | +| 0 | 1 | 0 | 1 | + +Man kann subtrahieren durch Addieren indem man aus der zu Subtrahierenden Zahl das Einserkomplement bildet. Aus 101101 wird dadur 010010 dies Addiert man mit der Zahl von der Subtrahiert werden soll, addiert eine weitere 1 und streicht dann die vorderste 1 aus dem Ergebnis. Die Zahlen müssen beide die gleiche Anzahl an stellen haben. Notfalls wird mit 0 vorne dran aufgefüllt. + +> Das Einserkomplement einer Dualzahl erhält man, indem man die Nullen der Zahl durch Einsen und ihre Einsen durch Nullen ersetzt. Ihr Zweierkomplement erhält man, indem man zu ihrem Einserkomplement noch 1 2 addiert. + +## Hexadezimal + +Zur besseren Lesbarkeit können lange Binärwerte in Hexadezimalwerte umgewandelt werden. Hierzu werden die Binärwerte von rechts nach links in 4er Blöcke eingeteilt (Fehlende stellen werden einfach mit 0en von vorne befüllt) und in ihren Dezimalwert und dann in den Hexadezimalwert überführt. + +Gegeben sei ${11001111101}_{2}$ von rechts beginnend ${1101}_{2}$, ${0111}_{2}$, ${0110}_{2}$. Wieder von rechts nach link die viererblöcke in ihren Hexadezimalwert umwandeln, daraus flogt +${0110}_{2} = 6 = {6}_{16}$, ${0111}_{2} = 7 = {7}_{16}$, ${1101}_{2} = 13 = {D}_{16}$ der Hexadezimalwert ${67D}_{16}$. + +| Binärwert | Dezimalwert | Hexadezimalwert | +|:----------|:------------|:----------------| +| 0000 | 0 | 0 | +| 0001 | 1 | 1 | +| 0010 | 2 | 2 | +| 0011 | 3 | 3 | +| 0100 | 4 | 4 | +| 0101 | 5 | 5 | +| 0110 | 6 | 6 | +| 0111 | 7 | 7 | +| 1000 | 8 | 8 | +| 1001 | 9 | 9 | +| 1010 | 10 | A | +| 1011 | 11 | B | +| 1100 | 12 | C | +| 1101 | 13 | D | +| 1110 | 14 | E | +| 1111 | 15 | F | + + +> Man erhält den hexadezimalen Wert einer Dualzahl, indem man sie von rechts +nach links in Vierergruppen zusammenfasst und die hexadezimalen Werte die- +ser Vierergruppen aufschreibt. Umgekehrt erhält man die duale Darstellung +einer Hexadezimalzahl, indem man die einzelnen hexadezimalen Ziffern in +duale Vierergruppen auflöst + +# Zeitkomplexität + +> Ist T(n) die von n abhängige Laufzeit eines Algorithmus und gibt es eine Zahl $c > 0$, sodass für alle n die Beziehung $T(n) \leq c · n$ gilt, so schreibt man kurz $T(n) = O(n)$ und sagt, die Zeitkomplexität ist von der Größenordnung O(n). Das Symbol O(n) wird als ein **Landau-Symbol** bezeichnet. + +> Sind f(n) und g(n) auf den natürlichen Zahlen definierte Funktionen mit positiven Werten, so gilt $f(n) = O(g(n))$, falls es eine konstante Zahl c gibt, sodass $f(n) \leq c · g(n)$ für alle hinreichend großen natürlichen Zahlen n gilt. + +# Die Turing Maschine + +**Aufbau:** +1. Ein Band mit beliebig vielen Speicherstellen +* Einem Lese/Schreibkopf um diese Speicherstellen auszulesen, zu löschen, zu beschreiben oder so zu belassen. +* Der Lese/Schreibkopf kann um eine Stelle nach links oder rechts rücken oder stehen bleiben. +* Schreiben kann der Kopf ein Alphabet aus endlich vielen Zeichen, zu denen immer das Leerzeichen "Blank" gehören muss. +* Das Alphabet hängt vom jeweiligen Programm der Turing-Maschine ab. +* Das Programm wird durch Anweisungen und verschiedene Zustände der Maschine beschrieben. + +``` +z_0 ,1 → z_1 ,a,R +z_1 ,1 → z_1 ,1,R +z_1 ,b → z_1 ,b,R +z_1 , → z_2 ,b,L +z_2 ,b → z_2 ,b,L +z_2 ,1 → z_2 ,1,L +z_2 ,a → z_0 ,1,R +z_0 ,b → z_0 ,1,R +z_0 , → z_E ,,H +``` +z_X beschreibt die verschiedenen Zustände. R und L die Richtung in die der Lesekopf sich bewegt. + +``` +z_0 , 1 -> z_1 ,1,R +z_1 , 1 -> z_1 ,1,R +z_1 , + -> z_2 ,1,R +z_2 , 1 -> z_2 ,1,R +z_2 ,  -> z_3 ,,L +z_3 , 1 -> z_E ,,H +``` + +# Von-Neumann-Architektur + +-- Folgt!! + +# Algorithmen + +**Definition:** +> Ein Algorithmus ist eine endliche Menge von eindeutig festgelegten Verfahrensvorschriften zur Lösung eines Problems durch eine in der Regel endliche Menge von Einzelschritten. + +**Definition Funktion:** +> Eine Funktion f heißt berechenbar, wenn es einen Algorithmus gibt, der für jedes Argument x den Funktionswert f (x) berechnet. + +## Charakteristische Eigenschaften +**TGI01** + +| Charakteristika | Beschreibung | +|:-----------------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| Finitheit | Die Vorschrift ist mit endlichen Mitteln beschreibbar. | +| Detterminismus | Es ist immer eindeutig definiert, welche Regel in der vorschrift als nächstes anzuwenden ist. | +| Determiniertheit | Die Ausgabe ist immer eindeutig bestimmt. | +| | | +| Platzkomplexität | Das Verfahren darf zu jedem Zeitpunkt nur angemessen viel Speicherplatz benötigen. | +| Zeitkomplexität/Terminiertheit | Das Verfahren sollte zu einem angemessenen Zeitpunkt terminieren. | + + +**GOP** + +| Charakteristika | Beschreibung | +|:-----------------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| Endlichkeit | Ein Algorithmus muss aus einer endlichen Anzahl von Lösungsschritten bestehen und nach Abarbeitung dieser endlich vielen Schritte nach einer endlichen Zeit das Ende erreichen. | +| Eindeutigkeit | Die einzelnen Schritte eines Algorithmus und ihre Aufeinanderfolge müssen ein deutig beschrieben sein. | +| Allgemeinheit | Ein Algorithmus darf nicht nur die Lösung einer speziellen Aufgabe (z.B. Sortieren einer konkreten Zahlenfolge), sondern muss die Lösung einer Klasse von Problemen (z.B. Sortieren einer beliebigen Zahlenfolge endlicher Länge) beschreiben. | +| Determiniertheit | Die mehrmalige Anwendung eines Algorithmus mit denselben Eingabedaten muss i.a. dieselben Ausgangsdaten liefern. | +| Effektivität | Ein Algorithmus muss real von einer Maschine durchführbar sein. | +| Effizienz | Ein Algorithmus muss möglichst wenig Speicher und eine möglichst geringe Rechenzeit erfordern. | + + +## Sortieren-Algorithmen + +### Anforderungen an Sortieralgorithmen + + +### QuickSort + +Prinzip: teile und herrsche (split) + +``` +Algorithmus: QuickSort + +Eingabe: Feld natürlicher Zahlen A +Ausgabe: Feld natürlicher Zahlen A +Problem: Sortiere A + +QuickSort(A) +1. Falls A.length() ≤ 1 gib A zurück +2. Wähle pivot := A.length()/2 +3. (split) Bilde für alle n <> pivot + A_1 = [A[n] | A[n] ≤ A[pivot]] + A_2 = [A[n] | A[n] > A[pivot]] +4. Rufe QuickSort rekursiv mit den beiden Listen auf: + A'_1 = QuickSort(A 1 ) + A'_2 = QuickSort(A 2 ) +5. (merge) Füge die Ergebnisse zusammen: + Setze A = A 0 1 + A[pivot] + A 0 2 +6. Gib A aus +``` + +### MergeSort + +Prinzip: teile und herrsche (merge) + +``` +Algorithmus: MergeSort + +Eingabe: Feld natürlicher Zahlen A +Ausgabe: Feld natürlicher Zahlen A +Problem: Sortiere A + +MergeSort(A) +1. Falls A.length() ≤ 1 gib A zurück +2. Wähle pivot := A.length()/2 +3. (split) Bilde für alle n + A_1 = [A[n] | n < pivot] + A_2 = [A[n] | n ≥ pivot] +4. Rufe MergeSort rekursiv mit den beiden Listen auf: + A'_1 = MergeSort(A 1 ) + A'_2 = MergeSort(A 2 ) +5. (merge) Füge die Ergebnisse zusammen: + Setze A = Merge(A 0 1 , A 0 2 ) +6. Gib A aus +``` + +### HeapSort + +Zeitkomplexität: $O\(n \cdot {log}_{2}\(n\)\)$ + +``` +Algorithmus: HeapSort + +Eingabe: Feld natürlicher Zahlen A +Ausgabe: Feld natürlicher Zahlen A +Problem: Sortiere A + +HeapSort(A) +1. Erstelle aus A einen Heap H +2. Solange der Heap H nicht leer ist + 2.1. Entnimm das oberste Element von H füge es von hinten in A ein. + 2.2. Bilde aus den entstandenen zwei Heaps wieder einen neuen Heap H +3. Gib A aus +``` + +### BubbleSort + +``` +Algorithmus: BubbleSort + +Eingabe: Feld natürlicher Zahlen A +Ausgabe: Feld natürlicher Zahlen A +Problem: Sortiere A + +BubbleSort(A) +1. i := 1 +2. Solange i < length(A) + 2.1. j := 1 + 2.2. Solange j < length(A) + 2.2.1. Falls A[ j] < A[ j + 1], dann tausche + 2.2.2. j := j + 1 + 2.3. i := i + 1 +3. Gib A aus +``` + +``` +Algorithmus: BubbleSort, Verbesserte Version + +Eingabe: Feld natürlicher Zahlen A +Ausgabe: Feld natürlicher Zahlen A +Problem: Sortiere A + +BubbleSort2(A) +1. i := 1 +2. Solange i < length(A) + 2.1. j := 1 + 2.2. Solange j < (length(A) − i + 1) + 2.2.1. Falls A[ j] < A[ j + 1], dann tausche + 2.2.2. j := j + 1 + 2.3. i := i + 1 +3. Gib A aus +``` + +### RedixSort + +Prinzip: linear +Bemerkung: benötigt extra großen Platz + +## Suchen-Algorithmen + +### Lineare Suche + +``` +Algorithmus: Lineare Suche, formal + +Eingabe: Wort w, Liste von Namen L +Ausgabe: wahr, f alsch +Problem: Ist w in L? +LineareSuche(w,L) + +1. i := 1 +2. Solange i ≤ Länge(L): + 2.1. Wenn L i == w, so beende mit wahr. + 2.2. Anderenfalls i := i + 1. +3. Beende mit f alsch. +``` + +### BinarySearch + +Vorraussetzung: Sortierte Liste + + +``` +Algorithmus: Binäre Suche + +Eingabe: Wort w, Liste von Namen L +Ausgabe: wahr, f alsch +Problem: Ist w in L? + +BinäreSuche(w,L) +1. first := 1 +2. last := Länge(L) +3. middle := ( first + last)/2 +4. Solange first ≤ last: + 4.1. Wenn L middle < w, dann first := middle + 1. + 4.2. Anderenfalls, wenn L middle == w, dann beende mit wahr. + 4.3. Anderenfalls last := middle − 1. +5. Beende mit falsch. +``` + + +### HeapSearch + +### QuickSearch + +## Selektion-Algorithmen + +### QuickSelection + +``` +Algorithmus: QuickSelection + +Eingabe: Feld natürlicher Zahlen A, Zahl k +Ausgabe: Zahl i +Problem: k-größtes Element nach Sortierung von A + +QuickSelect(A,k) +1. Wähle pivot := A.length()/2 +2. (split) Bilde für alle A[n] + A_1 = [A[n] | A[n] < A[pivot]] + A_2 = [A[n] | A[n] ≥ A[pivot]] +3. Falls A_2.length() = k gibt A[pivot] aus +4. Falls A_2.length() > k rufe QuickSelection(A_2 , k) auf +5. Falls A_2.length() < k rufe QuickSelection(A_1 , k − A_2.length()) auf +``` + +### k-Selektion + +``` +Algorithmus: Selektion + +Eingabe: Feld natürlicher Zahlen A, Zahl k +Ausgabe: Zahlen i +Problem: k-größtes Element nach Sortierung von A + +kSelection(A,k) +1. BubbleSort(A) +2. Gib A[A.length() − k] aus +``` + +### Max-Search + +``` +Algorithmus: MaxSearch2 + +Eingabe: Feld natürlicher Zahlen A +Ausgabe: Zahl i +Problem: Maximum von A + +MaxSearch2(A) +1. i := 0 +2. Solange i < (A.length() − 1) + 2.1. Falls A[ j] < A[ j + 1], dann tausche + 2.2. j := j + 1 +3. Gib A[A.length() − 1] aus +``` + +``` +Algorithmus: MaxSearch3 + +Eingabe: Feld natürlicher Zahlen A +Ausgabe: Zahl i +Problem: Maximum von A + +MaxSearch3(A) +1. max := 0 +2. j := 1 +3. Solange j ≤ A.length() + 3.1. Falls A[ j] > A[max], dann max := j + 3.2. j := j + 1 +4. Gib A[max] aus +``` + +### MinMax-Selektion + +Prinzip: Tournament-Methode + +``` +Algorithmus: MinMaxSearch + +Eingabe: Feld natürlicher Zahlen A +Ausgabe: Zahlen i, j +Problem: Minimum und Maximum von A + +MinMaxSearch(A) +1. max := 0 +2. j := 1 +3. Solange j ≤ A.length() + 3.1. Falls A[ j] > A[max], dann max := j + 3.2. j := j + 1 +4. min := 0 +5. j := 1 +6. Solange j ≤ length(A) + 6.1. Falls A[ j] < A[min], dann min := j + 6.2. j := j + 1 +7. Gib A[min], A[max] aus +``` + +``` +Algorithmus: MinMaxSearch2 + +Eingabe: Feld natürlicher Zahlen A +Ausgabe: Zahlen i, j +Problem: Minimum und Maximum von A + +MinMaxSearch2(A) +1. max := 0 +2. min := 0 +3. j := 1 +4. Solange j ≤ length(A) + 4.1. Falls A[ j] > A[max], dann max := j + 4.2. Falls A[ j] < A[min], dann min := j + 4.3. j := j + 1 +5. Gib A[min], A[max] aus +``` + +### kmp-Matching + +Beim KMP-Matching erstellt man ein next Array um das Suchpattern immer um die Maximal möglichen Positionen nach vorne zu verschieben. Zur ermittlung dieses Array geht man wie folgt vor: + +Man nehme das Suchpattern und bestimmt für jede Position an der ein Fehler auftreten kann um wieviele stellen man das Pattern nach vorn verschieben kann. Beispiel p = 1010011, dann schaut man p'= 0 != 1 = p nun prüft man um wieviele stellen man p verschieben kann in dem man p' von hinten an p anlegt, next[0] = 0. Für + +| Position | p' = p[0-p'.length()] | next | +| --------- | ------------------------ | ------- | +| 0 | p' = 0 != 1 = p | next[0] = 0 | +| 1 | p'= 11 != 10 = p | next[1] = 0 | +| 2 | p' = 100 != 101 = p | next [2] = 1 | +| 3 | p' = 1011 != 1010 = p | next [3] = 1 | +| 4 | p' = 10101 != 10100 = p | next [4] = 3 | +| 5 | p' = 101000 != 101001 = p | next [5] = 0 | +| 6 | p' = 1010010 != 1010011 = p | next [6] = 2 | + +``` +Eingabe: Pattern P +Ausgabe: Array next +Problem: Erstelle KMP-Matching next Array + +kmpArray(p) +1. next[] := [] +2. i := 0 +3. Solange i < p.length() + 3.1. p1 := p[0:i] + 3.2. pruef := p... +``` + +### Boyer-Moore-Matching + +### Robin-Karp-Matching + +# Sonstige-Algorithmen + +## Polnische Notation + +``` +Algorithmus: Erzeuge inverse polnische Notation + +Eingabe: Infix-Zeichenkette: I +Ausgabe: Postfix-Zeichenkette: P +Problem: Inverse polnische Notation + +WandlePost f ix(I) +1. S = init() +2. Solange length(I) > 0 + 2.1. z := nextZeichen(I) + 2.2. Falls z eine Ziffer, so P := P · z + 2.3. Falls z ein Operator, so S.put(z) + 2.4. Falls z eine öffnende Klammer, so tue nichts. + 2.5. Falls z eine schließende Klammer, P := P · S.pop() +3. Gegebenenfalls füge Reststapel S noch an P an. +4. Gib P aus. +``` + +## Hashing + +## schnelles Multiplizieren