Algorithmen und Datenstrukturen II - Technische Fakultät · PDF fileSyntax und Semantik...

Syntax und Semantik Java: Der Einstieg Imperative Programmierung in Java Algorithmen zur exakten Suche in Texten Objektorientierte Programmierung in Java Ubergang von funktionaler zu OOP Programmieren im Großen Hashing Ein- und Ausgabe Grafische Benutzeroberflachen Graphen

Algorithmen und Datenstrukturen II

Peter Steffen

AG Praktische InformatikTechnische FakultatUniversitat Bielefeld

Vorlesung Sommer 2009

Peter Steffen Universitat Bielefeld

A&D II, Vorlesung 2009


Veranstalter

Vorlesung und Ubungen

Peter SteffenRaum: M3-124

Tel.: 0521/106-2906Email: [email protected]




Webseite zur Vorlesung

Informationen zur Vorlesung und den Ubungen

Folien, Skript, Ubungszettel

http://www.techfak.uni-bielefeld.de/ags/pi/lehre/AuDIISS09/

Account-Antrag:

https://www.techfak.uni-bielefeld.de/rechner/accountantrag.html

Abholung nach ca. 2 Tagen im Support-Buro M3-100.








Ubungsgruppen

Anmeldung zu den Ubungen durch Eintrag auf den Listen amschwarzen Brett der Technischen Fakultat

Zeitraum der Anmeldung:Dienstag 14.4., ca. 15 Uhr bis Donnerstag 16.4., 16 Uhr

Raumnummern und Tutoren werden ab Freitag, dem 17.4.,am schwarzen Brett bekanntgegeben




Aufgabenzettel

erstes Ubungsblatt am 21.4.(dann jeweils am Dienstag in der Vorlesung)

Aufgaben in Gruppen von 3 Studierenden bearbeiten

Losungen werden eine Woche nach der Ausgabe in derVorlesung eingesammelt

Leistungsnachweis:

1 mindestens 50% der moglichen Punktzahl in den Ubungszetteln2 erfolgreiche Bearbeitung der Projektaufgabe3 regelmaßige aktive Teilnahme an den Ubungen. Es darf

maximal zweimal unentschuldigt gefehlt werden. Ansonsten istein arztliches Attest erforderlich.

Die Ubungen beginnen in der Woche vom 20.04 bis 24.04.




Einzelprojekt

Vorbereitung auf TdPE Veranstaltung

Java-Programmieraufgabe als Einzelarbeit

Ausgabe der Projektaufgabe am 23.06.09

Abgabe der Losungen spatestens am 14.07.09




Ubersicht

1 Syntax und Semantik

2 Java: Der Einstieg

3 Imperative Programmierung in Java

4 Algorithmen zur exakten Suche in Texten

5 Objektorientierte Programmierung in Java

6 Ubergang von funktionaler zu OOP

7 Programmieren im Großen

8 Hashing

9 Ein- und Ausgabe

10 Grafische Benutzeroberflachen

11 Graphen



Einfuhrung Formale Sprachen Kontextfreie Grammatiken EBNF-Definitionen

Teil I

Syntax und Semantik




Einfuhrung

Programmiersprachen sind formale Sprachen. Es ist prazisefestgelegt,

welche Zeichenreihen uberhaupt Programme einer Sprache Lsind (Syntax),

welche Ein-/Ausgabefunktion ein Programm berechnet(Semantik).




Konkrete/abstrakte Syntax

konkrete Syntax

Genaue textuelle Aufschreibung fur Programme.

abstrakte Syntax

Bindeglied zur Semantik; gibt an, wie ein Programm(-stuck)aufgebaut ist.




Beispiel

abstrakt

assign

��

@@R

x add

��

@@R

var const

��

@@R

y 5

konkret

x := y + 5 Pascalx = y + 5 C, Fortran, JavaLET x = y + 5 Basic (anno 1963)ADD 5 TO y GIVING x COBOLSTORE y + 5 TO x dBase




Operatoren und Konstrukte

In der abstrakten Syntax tauchen die primitiven Konstrukte einerProgrammiersprache auf, sowie Operatoren, die diese zu neuenKonstrukten kombinieren.

primitiv: Bezeichner, ZahlKombination: var: Bezeichner → Ausdruck

const: Zahl → Ausdruckadd: Ausdruck × Ausdruck → Ausdruckassign: Bezeichner × Ausdruck → Anweisung




Worter

Definition

Ein Alphabet A ist ein endlicher Zeichenvorrat (eine endlicheMenge).

Die Mengen aller endlichen Zeichenreihen uber einemAlphabet A bezeichnen wir mit A∗.

Das leere Wort der Lange 0 bezeichnen wir mit ε.




Formale Sprachen

Definition

Eine Menge L ⊆ A∗ heißt formale Sprache uber dem Alphabet A.

Einen abstrakteren Sprachbegriff kann man kaum definieren. Dieeinzige Frage, die man sich uber w ∈ A∗ stellen kann, ist: Giltw ∈ L oder w 6∈ L? Diese Frage nennt man das Wortproblem vonL.




Programmiersprachen

Definition

Eine Programmiersprache ist ein Paar (L,L), wobei L ⊆ A∗ eineformale Sprache und L : L→ (A∗ → A∗) die Semantik von L ist.

Damit ordnet L jedem L-Programm l ∈ L als seine Bedeutung dieEin-/Ausgabefunktion L(l) zu, wobei Ein- und Ausgabe ebenfallsZeichenreihen uber A sind. Fur L(l) schreiben wir auch kurz Ll .




Kontextfreie Grammatiken

Definition

Eine kontextfreie Grammatik ist ein 4-Tupel G = (N,A,P,S),wobei

1 N ein Alphabet von sogenannten Nonterminalsymbolen,

2 A ein Alphabet von sogenannten Terminalsymbolen mitN ∩ A = ∅,

3 P eine endliche Menge von Produktionen (Regeln) der FormV → α mit V ∈ N und α ∈ (V ∪ A)∗ und

4 S ∈ N ein Startsymbol ist.




Satzformen einer Grammatik

Die Menge S(G) der Satzformen von G ist die kleinste Teilmengevon (N ∪ A)∗ mit den folgenden Eigenschaften:

1 S ∈ S(G).2 Wenn αVβ ∈ S(G) fur ein Nonterminalsymbol V ∈ N und

Zeichenfolgen α, β ∈ (N ∪ A)∗ und wenn V → γ ∈ P eineRegel ist, so gilt auch αγβ ∈ S(G) (

”Ableitungsschritt“).




Sprache einer Grammatik

Die durch G definierte Sprache ist L(G) def= S(G) ∩ A∗. Den Test,

ob ein gegebenes Wort w durch eine Grammatik G erzeugt werdenkann, also ob w ∈ L(G) gilt, nennt man das Wortproblem von G.




Syntax und Semantik von Sprachen: Bohrkopfsteuerung

N

S

EW

O

N,E ,W ,S : Bewegung um 1 Gitterpunkt (north, east, west,south)

O: Einstellen auf Nullpunkt (origin)D: Senken des Bohrkopfes mit Bohrung (drill)U: Heben des Bohrkopfes (up)




Programme zur Maschinensteuerung

“ONNNEEDO” Bohrung am Punkt (2,3)mit Ruckkehr zum Nullpunkt

“ODUDUDU” Dreifach-Bohrung am Nullpunkt

“DUNDUWDUSDU” bohrt Gitterquadrat, wo der Kopf gerade steht




Steuersprache

In der ersten Variante unserer Steuersprache lassen wir beliebigeBefehlsfolgen zu. Außerdem kann jedes Programm als Eingabe einPaar von Start-Koordinaten erhalten.

L1 = {N,E ,W ,S ,U,D,O}∗Eingabe: (Int, Int)

L1 : L1 → (Int, Int)→ [(Int, Int)]




Maschinenzustand

x aktuelle x-Koordinatey aktuelle y-Koordinatel aktueller Hebezustand des Bohrkopfes: 0 gesenkt, 1 obencs Liste bisheriger Bohr-Koordinaten




Semantik von Befehlen

bef :: Befehl → Zustand → Zustandbef b (x , y , l , cs) = case b ofO → (0, 0, 1, cs)N → (x , y + 1, l , cs)W → (x − 1, y , l , cs)S → (x , y − 1, l , cs)E → (x + 1, y , l , cs)D → (x , y , 0, (x , y) : cs)U → (x , y , 1, cs)




Befehlsfolgen

beff :: Befehl∗ → Zustand → [(Int, Int)]beff [ ](x , y , l , cs) = reverse csbeff (b : bs)(x , y , l , cs) = beff bs(bef b (x , y , l , cs))

Die Semantik L1 wird beschrieben durch die Funktion

prog :: Befehl∗ → (Int, Int)→ [(Int, Int)]prog bs (i , j) = beff bs (i , j , 1, [])




Programmiersprache L1 und ihre Semantik L1 sind sehr naiv. Mansollte zum Beispiel bedenken, dass das Werkstuck und vielleichtauch die Maschine beschadigt werden, wenn mit abgesenktemBohrkopf Bewegungen ausgelost werden. Freilich – solangeniemand solche Steuerprogramme erzeugt, geht alles gut. Jedochwollen wir uns nicht darauf verlassen . . .




Syntaktische vs. semantische Verfeinerung

Generell gibt es zwei Moglichkeiten, eine Sprache (L,L) zuverfeinern: syntaktisch oder semantisch.Semantisch heisst: das“Ungluck”kann programmiert werden, trittaber nicht ein.Syntaktisch heisst: das“Ungluck”wird bereits als syntaktischfehlerhaftes Programm abgewiesen.




Aufgabe

Modifiziere die Semantik L1 (bei unverandertem L1) in zweiverschiedenen Weisen. Tritt eine Bewegung mit abgesenktemBohrkopf auf, so wirda) die Ausfuhrung des Programms abgebrochen und nur die

Koordinaten der bisherigen Bohrungen ausgegeben,b) die Ausfuhrung des Programms abgebrochen und keine

Koordinaten angegeben.




Forderungen an die Steuersprache

Wir entscheiden uns nun fur die syntaktische Verfeinerung undstellen Forderungen an die Steuersprache L:

1 Auf Befehl D muss stets U oder O folgen.

2 Befehl O ist immer moglich, U nur unmittelbar nach D.

3 Alle Programme enden mit dem Bohrkopf am Nullpunkt.

4 Auf dem Weg von einer Bohrung zur nachsten sindgegenlaufige Richtungswechsel unerwunscht, zum Beispiel. . .NSNS . . . oder . . .NES . . . , weil sie die Maschine inSchwingung versetzen konnen.

Alle diese Forderungen lassen sich durch Einschrankungen von L1

erfullen, erfordern aber verfeinerte Methoden zur syntaktischenSprachbeschreibung. Solche Mittel sind Grammatiken.




Grammatik 1

Grammatik G1 (zur Beschreibung von L1)

A = { N,E ,W ,S ,U,D,O}N = { moves,move}S = movesP = { moves → ε| move moves

move → N|E |W |S |U|D|O}

Hier gilt L(G1) = A∗. Es ist w ∈ L(G1) mit

w = “WENDEDENUDOSUED ′′

Ubung: Leite w mit dieser Grammatik ab.




Verfeinerte Grammatik 2

Verfeinerte Grammatik G2 (berucksichtigt Forderungen (1) - (3),aber nicht (4)).

A,N,S wie G1

P = { moves → O|DO| move movesmove → N|E |W |S |O|DU|DO}

Frage: Warum brauchen wir die Regel moves → DO uberhaupt?Antwort: Sonst ist “DO” /∈ S(G2).






A,N,S wie G1


Frage: Warum brauchen wir die Regel moves → DO uberhaupt?

Antwort: Sonst ist “DO” /∈ S(G2).






A,N,S wie G1


Frage: Warum brauchen wir die Regel moves → DO uberhaupt?Antwort: Sonst ist “DO” /∈ S(G2).




Warum ist nun w =“WENDEDENUDOSUED” /∈ S(G2)?Versuch einer Ableitung:

moves → move moves→ W moves→ W move moves→ W E moves→3 W E N move moves→ W E N ?

Hier kann nur DU oder DO erzeugt werden, aber nicht D alleinoder DE .





Verfeinerte Grammatik G3 (berucksichtigt Forderungen (1) und(4), (2) nur teilweise und (3) gar nicht):

A,S wie G1

N = { moves, ne, nw, se, sw, drill }P = { moves → ε | ne moves | nw moves | se moves | sw moves

ne → N ne | E ne | drillse → S se | E se | drillnw → N nw | W nw | drillsw → S sw | W sw | drilldrill → DU|DO }




RNA-Sekundarstrukturen

Ein RNA-Molekul besteht aus Basen A,C,G,U. DurchWasserstoff-Brucken zwischen A–U, G–C, G–U bilden sichBasenpaarungen, die zu einer Sekundarstruktur fuhren.

Primarsequenz Sekundarstruktur

C A C C U A A G G U C C

C

A U

C C

C A C C U A A G G U C C

A

U A

C G

C G

← Helix-Bildung schafft Stabilitat




Sekundarstruktur-Grammatik

Grammatik zur Beschreibung der Sekundarstruktur (Ausschnitt):

A = { A, C, G, U }N = { struct, any, stack, loop }S = structP = { struct → any | any struct | struct any | stack | ε

any → A | C | G | Ustack → A stack U | U stack A |

G stack C | C stack G |G stack U | U stack G | loop

loop → any loop | any any any }




Ableitung von RNA-Sequenzen

Allein mit den ersten beiden Produktionen kann man alleRNA-Sequenzen ableiten:

struct → any struct → A struct → A any struct → AC struct . . .

Damit ist L(G) = A∗. Der Witz der Grammatik ist, dass mancheAbleitungen das Vorliegen moglicher Sekundarstrukturen anzeigen– dann namlich, wenn sie die Produktionen fur stack benutzen.




Ableitung == Struktur

struct →2 C struct →4 C struct CC → C stack CC→ CA stack UCC →2 CACC stack GGUCC → CACC loop GGUCC→4 CACCUAAGGUCC




Syntaxbaumstruct

��any

��C

structHH

anyHH

Cstruct

HHany

HHC

struct

stack��

AHH

Ustack��

CHH

Gstack��

CHH

Gstack

loop��

any��

U

HHany

HHA

any

APeter Steffen Universitat Bielefeld



EBNF, Historisches

Syntaxbeschreibung von FORTRAN und COBOL (amAnfang) durch Beispiele und Gegenbeispiele.

1958 formale Beschreibung der Syntax von ALGOL durchJohn Backus; Backus-Normalform (BNF).

Kleine Verbesserungen in der Notation durch Peter Naur,daher spricht man heute von der Backus-Naur-Form (BNF).

Niklaus Wirth hat die Backus-Naur-Form noch einmaluberarbeitet und erweitert (EBNF – Extended BNF).




EBNF, Definition

Die Metazeichen der EBNF (vgl. Klaeren [5], S. 104) sind:das Definitionszeichen =das Alternativzeichen |die Anfuhrungszeichen ‘‘ ’’die Wiederholungsklammern { }die Optionsklammern [ ]die Gruppenklammern ( )der Punkt .




EBNF, Terme

Die Menge ET der EBNF-Terme ist gegeben durch:

1 Ist V eine Folge von Buchstaben und Ziffern, die mit einemBuchstaben beginnt, so gilt V ∈ ET und gilt alsNonterminalsymbol.

2 Ist w eine Folge von beliebigen Symbolen, so ist“w”∈ ET undgilt als ein (!) Terminalsymbol.

3 Fur α ∈ ET sind auch

1 (α) ∈ ET ,2 [α] ∈ ET und3 {α} ∈ ET .

4 Fur α1, . . . , αn ∈ ET sind auch

1 α1| . . . |αn ∈ ET und2 α1α2 . . . αn ∈ ET .




EBNF, Terme





1 (α) ∈ ET ,

2 [α] ∈ ET und3 {α} ∈ ET .


1 α1| . . . |αn ∈ ET und2 α1α2 . . . αn ∈ ET .




EBNF, Terme





1 (α) ∈ ET ,2 [α] ∈ ET und

3 {α} ∈ ET .


1 α1| . . . |αn ∈ ET und2 α1α2 . . . αn ∈ ET .




EBNF, Terme





1 (α) ∈ ET ,2 [α] ∈ ET und3 {α} ∈ ET .


1 α1| . . . |αn ∈ ET und2 α1α2 . . . αn ∈ ET .




EBNF, Terme





1 (α) ∈ ET ,2 [α] ∈ ET und3 {α} ∈ ET .


1 α1| . . . |αn ∈ ET und

2 α1α2 . . . αn ∈ ET .




EBNF, Terme





1 (α) ∈ ET ,2 [α] ∈ ET und3 {α} ∈ ET .


1 α1| . . . |αn ∈ ET und2 α1α2 . . . αn ∈ ET .




EBNF-Definitionen

Eine EBNF-Definition besteht aus einer endlichen Menge vonEBNF-Regeln der Form

V = α.

wobei V ein Nonterminalsymbol entsprechend obiger Konventionund α ein EBNF-Term ist. Das Nonterminalsymbol auf der linkenSeite der ersten Regel ist das Startsymbol.




EBNF-Definition fur Mini-Java (1)

program =“class” ident“{”mainMethod“}”.mainMethod =“public”“static”“void”“main”“(”“String”“[”“]”argsIdent“)”block.statement =“int” ident“=” expression“;”

| ident“=” expression“;”|“if”“(” condition“)” statement|“while”“(” condition“)” statement| block|“System”“.”“out”“.”“println”“(” expression“)”“;”|“;”|“int”“[”“]”arrayIdent“=”“new”“int”“[” expression“]”“;”| arrayIdent“[” expression“]”“=” expression“;”.

block =“{”{ statement }“}”.condition = expression ( “==” |“!=” |“<” |“<=” |“>” |“>=” ) expression.expression = [ (“+” |“-” ) ] term { ( “+” |“-” ) term }.term = factor { ( “*” |“/” ) factor }.





factor = ident| number|“(” expression“)”|“Integer”“.”“parseInt”“(”argsIdent“[” expression“]”“)”| argsIdent“.”“length”| arrayIdent“.”“length”| arrayIdent“[” expression“]”.

ident = ( letter |“_” |“$” ) { letter | digit }.number = (“0” | digit { digit |“0”} ).digit =“1” |“2” | . . . |“9”.letter =“A” | . . . |“Z” |“a” | . . . |“ z”.argsIdent = ident.arrayIdent = ident.




Operationen auf Sprachen

Seien L, L1 und L2 beliebige Sprachen (Wortmengen) uber einemgemeinsamen Alphabet. Dann definieren wir:

1. Komplex-Produkt: L1L2def= {w1w2 | w1 ∈ L1,w2 ∈ L2}

(also L∅ = ∅L = ∅; L{ε} = {ε}L = L)

2. n-fache Iteration: L0 def= {ε}, Ln+1 := LLn

3. Stern-Operation: L∗def=

⋃n∈N Ln




Semantik der EBNF (1)

Die Semantik der EBNF definieren wir durch Rekursion uber dieEBNF-Terme. Sei E eine EBNF-Definition (wobei S dasStartsymbol, N die Menge der Nonterminals und A die Menge derTerminals sei) und ET die Menge der EBNF-Terme. Dann ist dievon E erzeugte Sprache L(E) definiert als JSKE , wobei

J KE : ET P(A∗)

wie folgt definiert ist (vgl. Klaeren [5], S. 107):




Semantik der EBNF (2)

1 Fur V ∈ N ist

JV KEdef=

{JαKE falls V = α. eine Regel in E ist∅ sonst

2 J“w”KEdef= {w}

3q(α)

yE

def= JαKE

4q[α]

yE

def= {ε} ∪ JαKE

5q{α}

yE

def= JαK∗E

6 Jα1 . . . αnKEdef= Jα1KE . . . JαnKE

7 Jα1 | · · · | αnKEdef= Jα1KE ∪ · · · ∪ JαnKE




Beispiel eines syntaktisch korrekten Mini-Java-Programms

class BubbleSort {

public static void main(String[] args) {

int[] array = new int[args.length];

int i = 0;

while (i < args.length) {

array[i] = Integer.parseInt(args[i]);

i = i+1;

}

i = 1;

while (i < array.length) {

int j = array.length - 1;

while (j >= i) {

if (array[j] < array[j-1]) {

int tmp = array[j];

array[j] = array[j-1];

array[j-1] = tmp;

}

j = j-1;

}

i = i+1;

}

i = 0;

while (i < array.length) {

System.out.println(array[i]);

i = i+1;

}

}

}





program =“class” ident“{”mainMethod“}”.mainMethod =“public”“static”“void”“main”“(”“String”“[”“]”argsIdent“)”block.statement =“int” ident“=” expression“;”

| ident“=” expression“;”|“if”“(” condition“)” statement|“while”“(” condition“)” statement| block|“System”“.”“out”“.”“println”“(” expression“)”“;”|“;”|“int”“[”“]”arrayIdent“=”“new”“int”“[” expression“]”“;”| arrayIdent“[” expression“]”“=” expression“;”.

block =“{”{ statement }“}”.condition = expression ( “==” |“!=” |“<” |“<=” |“>” |“>=” ) expression.expression = [ (“+” |“-” ) ] term { ( “+” |“-” ) term }.term = factor { ( “*” |“/” ) factor }.





factor = ident| number|“(” expression“)”|“Integer”“.”“parseInt”“(”argsIdent“[” expression“]”“)”| argsIdent“.”“length”| arrayIdent“.”“length”| arrayIdent“[” expression“]”.

ident = ( letter |“_” |“$” ) { letter | digit }.number = (“0” | digit { digit |“0”} ).digit =“1” |“2” | . . . |“9”.letter =“A” | . . . |“Z” |“a” | . . . |“ z”.argsIdent = ident.arrayIdent = ident.




Syntaxdiagramme fur EBNF-Definitionen (1)

“w” : -��w - fur alle w ∈ A.

V : - V - fur alle V ∈ N.

[α] :

-

? -

α

{α} : ?

�

-

α




Syntaxdiagramme fur EBNF-Definitionen (2)

α1 . . . αn : - α1 - · · · - αn -

α1 | · · · | αn : - α1 -

...

- αn

6




Beispiel: Syntaxdiagramme fur Mini-Java (1)

program

{ }mainMethodclass ident

staticpublic void main

( [ ] argsIdent ) blockString

mainMethod




Beispiel: Syntaxdiagramme fur Mini-Java (2)statement

int = expression ;ident

if ( statement)condition

while condition )( statement

int

;

[ ] arrayIdent =

expression ] = expression ;[arrayIdent

;]expression[intnew

System . out . println ( ) ;expression

block

ident expression ;=





block

{

statement

}

expression expression==

!=

<

>=

>

<=

condition





expression

+

−

term

−

term +

/

*

factor

factor

term





factor

number

( expression )

argsIdent

arrayIdent

.

.

length

length

Integer .

arrayIdent ][ expression

parseInt ( argsIdent [ expression ] )

ident





ident

letter

letter

digit

_

$

digit

digit

0

0

number





digit

1

...

9

letter

...

A

Z

a

z

...




K. Arnold, J. Gosling: JavaTM - Die Programmiersprache.Addison-Wesley, 1996.

T.H. Cormen, C.E. Leierson, R.L. Rivest: Introduction toAlgorithms. MIT Press, 1990.

D. Flanagan: Java in a Nutshell. O’Reilly & Associates Inc.,1996.

F. Jobst: Programmieren in Java. Hanser Verlag, 1996.

H. Klaeren: Vom Problem zum Programm. 2.Auflage,B.G. Teubner Verlag, 1991.

K. Echtle, M. Goedicke: Lehrbuch der Programmierung mitJava. dpunkt-Verlag, 2000.



Algorithmen und Datenstrukturen II - Technische Fakultät · PDF fileSyntax und Semantik...

Documents

Transcript of Algorithmen und Datenstrukturen II - Technische Fakultät · PDF fileSyntax und Semantik...