Post on 05-Apr-2015
ListenListen
Klaus Becker2003
2
KB
List
en
ListenListen
Ansgar A., Speyer
Claudia B., Koblenz
Knut B., Neustadt
Annett B., Wörrstadt
Stefani D., Bad Ems
Jochen F., Ludwigshafen
...
...
Wieland S., Trier
Harald T.-R., Biesdorf
3
KB
List
en
Teil 1Teil 1
Objektorientierte Modellierung und Implementierung von Listen
4
KB
List
en
Was ist eine Liste?Was ist eine Liste?
Lisa
Roland
Anna
Gerd
Stefanie
Susanne
Walter
Ulrike
Theo
...
Bernd
Eine Liste ist eine endliche, beliebig lange Folge von Elementen, in der an jeder Stelle neue Elemente eingefügt oder vorhandene Elemente entfernt werden können.
Ziel ist es zunächst, die dynamische Datenstruktur „Liste“ mit Hilfe einer geeigneten Klasse zu implementieren.
Ziel ist es zunächst, die dynamische Datenstruktur „Liste“ mit Hilfe einer geeigneten Klasse zu implementieren.
5
KB
List
en
Objektorientierte RepräsentationObjektorientierte Repräsentation
... = Lisa
... = Roland
... = Anna
... = Gerd
... = Bernd
...
Lisa
Roland
Anna
Gerd
Stefanie
Susanne
Walter
Ulrike
...
Bernd
6
KB
List
en
Objektorientierte RepräsentationObjektorientierte Repräsentation
... = Lisa
... = Roland
... = Anna
... = Gerd
... = Bernd
Die Listenelemente werden mit Hilfe von Objekten beschrieben.
Die Folgenstruktur der Liste wird mit Hilfe von Referenzen aufgebaut.
...
7
KB
List
en
Objektorientierte RepräsentationObjektorientierte Repräsentation
... = Lisa
... = Roland
... = Anna
... = Gerd
... = Bernd
...
Knoten
8
KB
List
en
Objektorientierte RepräsentationObjektorientierte Repräsentation
Spezielle Liste: String-Liste
Verallgemeinerte Liste: Objekt-Liste
9
KB
List
en
KlassendiagrammKlassendiagramm
Liste
anfang: Knoten
...
Knoten
next: Knoteninhalt: string
...
Spezielle Liste:
kenntkennt
10
KB
List
en
KlassendiagrammKlassendiagramm
Liste
anfang: Knoten
...
Knoten
next: Knoteninhalt:
...
Object
Verallgemeinerte Liste:
kenntkennt
hat
11
KB
List
en
ImplementierungImplementierung
type TKnoten = class private next : TKnoten; inhalt : TObject; public ... end;
type TListe = class private anfang : TKnoten; public ... end;
Liste
anfang: Knoten
...
Knoten
next: Knoteninhalt:
...
Object
12
KB
List
en
ListenoperationenListenoperationen
{ liste: [ ] }
liste.create
{ liste: [Lisa] }
liste.insert(0, Lisa)
{ liste: [Lisa; Anna] }
liste.insert(1, Anna)
liste.insert(1, Roland)
{ liste: [Lisa; Roland; Anna] }
{ liste: [Lisa; Anna] }
liste.delete(1)
liste.items(1) Anna
liste.getCount 2
Liste
- anfang: Knoten- count: integer
+ create+ getCount: integer- knotenItems(pos: integer) : Knoten+ items(pos: integer): Object+ delete(pos: integer)+ insert(pos: integer; obj: Object)
Hilfsoperation
13
KB
List
en
knotenItems – SpezifikationknotenItems – Spezifikation
liste.knotenItems(2)
Die Funktion „knotenItems“ bestimmt den i-ten Knoten der Liste, wobei i = pos+1.
function TListe.knotenItems(pos: integer): TKnoten;
14
KB
List
en
liste.knotenItems(2) – Traceliste.knotenItems(2) – Trace
z := 0; k := anfang;
15
KB
List
en
liste.knotenItems(2) – Traceliste.knotenItems(2) – Trace
inc(z); k := k.getNext;
16
KB
List
en
liste.knotenItems(2) – Traceliste.knotenItems(2) – Trace
inc(z); k := k.getNext;
17
KB
List
en
liste.knotenItems(2) – Traceliste.knotenItems(2) – Trace
result := k;
18
KB
List
en
knotenItems – AlgorithmusknotenItems – Algorithmus
begin
z := 0;
k := anfang;
while ((z < pos) and (z < count)) do
begin
inc(z);
k := k.getNext;
end;
result := k;
end;
19
KB
List
en
items – Spezifikationitems – Spezifikation
liste.items(2)
Die Funktion „items“ bestimmt den Inhalt des i-ten Knotens der Liste, wobei i = pos+1.
function TListe.items(pos: integer): TObject;
20
KB
List
en
items – Algorithmusitems – Algorithmus
function TListe.items (pos: integer): TObject;
begin
if ((pos >= 0) and (pos < count)) then
result := knotenItems(pos).getInhalt
else
result := nil;
end;
21
KB
List
en
delete – Spezifikationdelete – Spezifikation
liste.delete(2)
procedure TListe.delete(pos: integer);
22
KB
List
en
liste.delete(2) – Trace liste.delete(2) – Trace
hilf := knotenItems(pos);
23
KB
List
en
liste.delete(2) – Traceliste.delete(2) – Trace
knotenItems(pos-1). setNext(knotenItems(pos).getNext);
24
KB
List
en
liste.delete(2) – Traceliste.delete(2) – Trace
hilf.getInhalt.free; hilf.free;dec(count)
25
KB
List
en
Achtung: liste.delete(0)Achtung: liste.delete(0)
knotenItems(pos-1). setNext(knotenItems(pos).getNext);
26
KB
List
en
Achtung: liste.delete(0)Achtung: liste.delete(0)
anfang := knotenItems(pos).getNext
27
KB
List
en
delete – Algorithmusdelete – Algorithmus
28
KB
List
en
insert – Spezifikationinsert – Spezifikation
liste.insert(2,o)
procedure TListe.insert(pos: integer; obj: TObject);
29
KB
List
en
liste.insert(2,o) – Traceliste.insert(2,o) – Trace
danach := knotenItems(pos);
30
KB
List
en
liste.insert(2,o) – Traceliste.insert(2,o) – Trace
neu := TKnoten.create(danach,obj);
31
KB
List
en
liste.insert(2,o) – Traceliste.insert(2,o) – Trace
knotenItems(pos-1).setNext(neu);inc(count);
32
KB
List
en
Vorsicht: liste.insert(0,o)Vorsicht: liste.insert(0,o)
knotenItems(pos-1).setNext(neu);
33
KB
List
en
insert – Algorithmusinsert – Algorithmus
34
KB
List
en
AufgabeAufgabe
Entwickeln Sie mit Hilfe der Trace-Beispiele die Algorithmen zu den beiden Operationen delete und insert.
Erstellen Sie ein neues Delphi-Projekt (in einem neuen Ordner) und implementieren Sie die Klasse TListe.
35
KB
List
en
Lösung: delete – AlgorithmusLösung: delete – Algorithmus
procedure TListe.delete(pos: integer); var hilf: TKnoten;beginif pos <= count-1 then begin hilf := knotenItems(pos); if pos = 0 then anfang := knotenItems(pos).getNext else knotenItems(pos-1).setNext(knotenItems(pos).getNext); hilf.getInhalt.free; hilf.free; dec(count); end;end;
36
KB
List
en
Lösung: insert – AlgorithmusLösung: insert – Algorithmus
procedure TListe.insert (pos: integer; obj: TObject); var neu, danach: TKnoten;beginif pos <= count then begin if pos = 0 then begin danach := anfang; neu := TKnoten.create(danach, obj); anfang := neu; inc(count); end else begin danach := knotenItems(pos); neu := TKnoten.create(danach, obj); knotenItems(pos-1).setNext(neu); inc(count); end; end;end;
37
KB
List
en
ListentestListentest
Ziel ist es, ein Programm zu erstellen, mit dessen Hilfe die Implementierung der Klasse „TListe“ gestestet werden kann.
Z. B.: Es soll eine Namensliste [Lisa; Anna; ...] erstellt und angezeigt werden.
Ziel ist es, ein Programm zu erstellen, mit dessen Hilfe die Implementierung der Klasse „TListe“ gestestet werden kann.
Z. B.: Es soll eine Namensliste [Lisa; Anna; ...] erstellt und angezeigt werden.
38
KB
List
enSpezialisierungSpezialisierung
Spezialisierte Liste:
Allgemeine Liste:
39
KB
List
enSpezialisierungSpezialisierung
Liste
anfang: Knoten
...
Knoten
next: Knoteninhalt:
... Element
Object
wert: String
create(w: String)setWert(w: String)getWert: String
kenntkennt
hatist
40
KB
List
en
Erzeugung einer ListeErzeugung einer Liste
liste := TListe.create;
e := TElement.create('Lisa');
liste.insert(0,e);
e := TElement.create('Anna');
liste.insert(1,e);
...
41
KB
List
en
Anzeige einer ListeAnzeige einer Liste
h := '';
for i := 0 to liste.getCount-1 do
begin
w := TElement(liste.items(i)).getWert;
h := h + ' ' + w;
end;
PListe.Caption := h;
Hilfsvariable
Anzeige-Panel
Typumwandlung: TObject TElement
42
KB
List
en
AufgabeAufgabe
Die Klasse „TElement“ ist noch nicht implementiert. Ergänzen Sie die fehlenden Teile.
Erstellen Sie eine einfache Testoberfläche und ergänzen Sie die Methodenaufrufe zur Erzeugung und zur Anzeige einer Testliste
Zur Kontrolle: Listen2
43
KB
List
en
Teil 2Teil 2
Anwendung: Lexikon
44
KB
List
en
AuftragAuftrag
Aus: H. Balzert: Lehrbuch Grundlagen der Informatik, S. 137.
Ziel ist es, ein Programm zur Erstellung und Benutzung eines Glossars (Lexikons) zu entwickeln.
Ziel ist es, ein Programm zur Erstellung und Benutzung eines Glossars (Lexikons) zu entwickeln.
45
KB
List
en
PflichtenheftPflichtenheft
/0/ Das Lexikon ist eine endliche Folge von Einträgen. Jeder Eintrag liefert eine Erläuterung zu einem Stichwort.
/1/ Im Lexikon kann der Benutzer eine Erklärung zu einem Stichwort nachschlagen. Der Benutzer muss hierzu das ihn interessierende Stichwort eingeben.
/2/ Das Lexikon kann vom Benutzer ergänzt und verändert werden: Es können jederzeit neue Einträge eingefügt und bereits bestehende Einträge gelöscht werden.
/3/ Das Lexikon kann extern gespeichert und wieder geladen werden.
46
KB
List
en
PrototypPrototyp
47
KB
List
en
OOAOOA
Ein Lexikon ist eine endliche Folge von Einträgen. Jeder Eintrag liefert eine Erläuterung zu einem Stichwort.
Im Lexikon kann man eine Erklärung zu einem Stichwort nachschlagen.
Das Lexikon kann ergänzt und verändert werden: Es können neue Einträge eingefügt und bereits bestehende Einträge gelöscht werden.
Das Lexikon kann extern gespeichert und wieder geladen werden.
48
KB
List
en
OODOOD
„create“ erstellt ein neues Listenobjekt „liste“.
„addEintrag“ erstellt zunächst ein „Eintrag“-Objekt und fügt es dann in „liste“ ein.
„delEintrag“ durchsucht zunächst die Liste „liste“ nach dem „stichwort“ und bestimmt gegebenenfalls die Position. Anschließend wird der zugehörige Eintrag in der Liste gelöscht.
„getErlaeuterung“ liefert zu dem „stichwort“ die zugehörige Erläuterung im Lexikon.
49
KB
List
en
AlgorithmenAlgorithmen
constructor TLexikon.create;beginliste := TListe.create(nil); end;
procedure TLexikon.addEintrag(stichwort, erlaeuterung: string); var eintrag: TEintrag;begineintrag := TEintrag.create(stichwort,erlaeuterung);liste.insert(0,eintrag); end;
50
KB
List
en
AlgorithmenAlgorithmen
procedure TLexikon.delEintrag(stichwort: string); var i, position: integer;beginposition := -1;for i := 0 to liste.getCount-1 do if TEintrag(liste.items(i)).getStichwort = stichwort then position := i; if position >= 0 then liste.delete(position); end;
51
KB
List
en
AlgorithmenAlgorithmen
function TLexikon.getErlaeuterung(stichwort: string): string; var position: integer; erlaeuterung: string;beginerlaeuterung := 'kein Eintrag gefunden!';for position := 0 to liste.getCount-1 do if TEintrag(liste.items(position)).getStichwort = stichwort then erlaeuterung := TEintrag(liste.items(position)).getErlaeuterung;result := erlaeuterung;end;
52
KB
List
en
AufgabeAufgabe
Delphi verfügt über eine vordefinierte Klasse „TList“. Informieren Sie sich über diese Klasse mit der Delphi-Hilfe. Implementieren Sie dann das Lexikon mit dieser vordefinierten Klasse „TList“ an Stelle der selbst entwickelten Klasse „TListe“.
Zur Kontrolle: siehe Lexikon2
53
KB
List
enZum VergleichZum Vergleich
unit uLexikon;interfaceuses uEintrag, classes {TList};type TLexikon = class private liste: TList; public constructor create; ... end;
unit uLexikon;interfaceuses uEintrag, uListe {TListe};type TLexikon = class private liste: TListe; public constructor create; ... end;
Vordefinierte Liste
Selbstdefinierte Liste
54
KB
List
enZum VergleichZum Vergleich
constructor TLexikon.create;beginliste := TListe.create; // liste := TList.create;end;
Vordefinierte Liste
Selbstdefinierte Liste
55
KB
List
enZum VergleichZum Vergleich
procedure TLexikon.addEintrag(stichwort, erlaeuterung: string); var eintrag: TEintrag;begineintrag := TEintrag.create(stichwort,erlaeuterung);liste.insert(0,eintrag); // liste.Insert(0, eintrag);end;
Vordefinierte Liste
Selbstdefinierte Liste
56
KB
List
enZum VergleichZum Vergleich
procedure TLexikon.delEintrag(stichwort: string); var i, position: integer;beginposition := -1;for i := 0 to liste.getCount-1 do // liste.Count-1 if TEintrag(liste.items(i)).getStichwort = stichwort then position := i; // liste.Items[i] if position >= 0 then liste.delete(position); // liste.Delete(position)end;
Vordefinierte Liste
Selbstdefinierte Liste
57
KB
List
enZum VergleichZum Vergleich
function TLexikon.getErlaeuterung(stichwort: string): string; var position: integer; erlaeuterung: string;beginerlaeuterung := 'kein Eintrag gefunden!';for position := 0 to liste.getCount-1 do // liste.Count-1 if TEintrag(liste.items(position)).getStichwort = stichwort then erlaeuterung := TEintrag(liste.items(position)).getErlaeuterung;result := erlaeuterung;end; // liste.Items[position]
Vordefinierte Liste
Selbstdefinierte Liste
58
KB
List
enZum VergleichZum Vergleich
TListe
- anfang: Knoten- count: integer
+ create(k: Knoten)+ getCount: integer- knotenItems(pos: integer) : Knoten+ items(pos: integer): TObject+ delete(pos: integer)+ insert(pos: integer; obj: TObject)
TList
+ Count: integer+ Items[pos: integer]: Pointer
+ create+ Delete(pos: integer)+ Insert(pos: integer; obj: Pointer)...
Properties
59
KB
List
en
Teil 3Teil 3
Stapel und Schlangen
60
KB
List
en
Auswertung von TermenAuswertung von Termen
Term: ( 7 - 2 ) * 3 =
7
(
-
( 7
2
( 7 -
)
*
5
3
* 5
( 7 - 2
=
* 5
3
15
OperandenstapelOperatorenstapel
61
KB
List
en
StapelStapel
LIFO-Prinzip: last in, first out
mitErstem erstes ohneErstes
62
KB
List
en
ModellierungModellierung
mitErstem erstes ohneErstes
Stapel
+ create+ istLeer: boolean+ mitErstem(obj: Object)+ erstes: Object+ ohneErstes
63
KB
List
en
DruckerwarteschlangeDruckerwarteschlange
Druckauftragswarteschlange
64
KB
List
en
SchlangeSchlange
FIFO-Prinzip: first in, first out
mitLetztem erstes ohneErstes
65
KB
List
en
ModellierungModellierung
mitLetztem erstes ohneErstes
Schlange
+ create+ istLeer: boolean+ mitLetztem(obj: Object)+ erstes: Object+ ohneErstes
66
KB
List
enVereinfachungVereinfachung
Im folgenden sollen nur Stapel und Schlangen betrachtet werden, deren Elemente Zeichenketten sind.
Stapel
+ create+ istLeer: boolean+ mitErstem(s: String)+ erstes: String+ ohneErstes
Schlange
+ create+ istLeer: boolean+ mitLetztem (s: String)+ erstes: String+ ohneErstes
67
KB
List
en
ImplementierungImplementierung
unit uStapel;
interface
uses classes {TStringList};
type
TStapel = class(TStringList) private public constructor create; function istLeer: boolean; procedure mitErstem(s: string); procedure ohneErstes; function erstes: string; end;
implementation
...
Stapel
+ create+ istLeer: boolean+ mitErstem(s: String)+ erstes: String+ ohneErstes
TStringList
+ Count: integer+ Strings: array[0..] of string
+ create+ delete(p: integer)+ insert(p: integer; s: String)...
68
KB
List
en
ImplementierungImplementierung
constructor TStapel.create;begin inherited create; end;
function TStapel.istLeer: boolean;begin result := (Count = 0); end;
function TStapel.erstes: string;begin result := Strings[0]; end;
procedure TStapel.ohneErstes;begin delete(0); end;
procedure TStapel.mitErstem(s: string);begin insert(0,s); end;
Stapel
+ create+ istLeer: boolean+ mitErstem(s: String)+ erstes: String+ ohneErstes
TStringList
+ Count: integer+ Strings: array[0..] of string
+ create+ delete(p: integer)+ insert(p: integer; s: String)...
69
KB
List
en
AufgabeAufgabe
Implementieren Sie analog die Klasse Schlange. Benutzen Sie hierzu die vordefinierte Delphi-Klasse TStringList. Die benötigten Attribute (Properties) und Operationen sind im nebenstehenden Klassendiagramm aufgeführt. Die Bedeutung der Bestandteile kann mit der Delphi-Hilfe ermittelt werden.
Erstellen Sie auch (einfache) Testprogramme, um die Korrektheit der Operationen zu überprüfen.
TStringList
+ Count: integer+ Strings: array[0..] of string
+ create+ delete(p: integer)+ insert(p: integer; s: String)...
Schlange
+ create+ istLeer: boolean+ mitLetztem (s: String)+ erstes: String+ ohneErstes
70
KB
List
en
71
KB
List
en
Teil 4Teil 4
Anwendung: Taschenrechner
72
KB
List
en
AuftragAuftrag
Es soll ein Demo-Taschenrechner erstellt werden, der die Bearbeitung von Klammertermen veranschaulicht.
Eingabe: ( 7 - 2 ) * 3 =
7
(
-
( 7
2
( 7 -
)
( 7 - 2
Verarbeitung:
Ergebnis: (7 - 2) * 3 = 15
73
KB
List
en
PflichtenheftPflichtenheft
/0/ Der Benutzer gibt die Bestandteile des Terms – auch Token genannt – Schritt für Schritt ein: Klammern, Zahlen, Rechenzeichen (+, -, *, :), Gleicheitszeichen. Z.B.: ( 7 - 2 ) * 3 =
/1/ Die Bearbeitung des Terms wird Schritt für Schritt mit Hilfe eines Buttons ausgelöst. Die benutzten Stapel werden dabei jeweils auf dem Bildschirm angezeigt./2/ Der gesamte Term und das berechnete Ergebnis wird abschließend angezeigt.
74
KB
List
en
Auswertung von TermenAuswertung von Termen
Term: ( 7 - 2 ) * 3 =
7
(
-
( 7
2
( 7 -
)
*
5
3
* 5
( 7 - 2
=
* 5
3
15
75
KB
List
en
InterpreterInterpreter
) * 3 =
(
-
7
2
termSchlange
operandenStapel
operatorenStapel
Interpreter
'(7-2'
''
76
KB
List
en
OOMOOM
) * 3 =
(
+
7
2
Interpreter
'(7-2)'
''
termSchlange
operandenStapel
operatorenStapel
77
KB
List
en
AufgabeAufgabe
Fall 1: Das erste Element der TermSchlange ist ein Gleichheitszeichen und der OperatorenStapel ist nicht leer:
=
-
7
'7-2'
''
Ergänzen Sie den Interpretieralgorithmus.
2
78
KB
List
en
AufgabeAufgabe
Fall 2: Das erste Element der TermSchlange ist ein Gleichheitszeichen und der OperatorenStapel ist leer:
Ergänzen Sie den Interpretieralgorithmus.
=
5
'(7-2)'
''
79
KB
List
en
AufgabeAufgabe
Fall 3: Das erste Element der TermSchlange ist „Klammerauf“:
Ergänzen Sie den Interpretieralgorithmus.
( 7 - 2 ) =
''
''
80
KB
List
en
AufgabeAufgabe
Fall 4: Das erste Element der TermSchlange ist „Klammerzu“:
Ergänzen Sie den Interpretieralgorithmus.
) =
(
-
7
'(7-2'
''
2
81
KB
List
en
AufgabeAufgabe
Fall 5: Das erste Element der TermSchlange ist ein Rechenzeichen:
Ergänzen Sie den Interpretieralgorithmus.
- 2 ) =
(
7
'(7'
''
82
KB
List
en
AufgabeAufgabe
Fall 6: Das erste Element der TermSchlange ist eine Zahl:
Ergänzen Sie den Interpretieralgorithmus.
2 ) =
(
-
7
'(7-'
''
83
KB
List
en
AufgabeAufgabe
Implementieren Sie den Interpreter und testen Sie das Taschenrechner-Programm.
Welche Erweiterungen wären wünschenswert?
84
KB
List
en
LösungLösung
Fall 1: Das erste Element der TermSchlange ist ein Gleichheitszeichen und der OperatorenStapel ist nicht leer:
=
-
7
'7-2'
''
2
hilf := termSchlange.erstes;termSchlange.ohneErstes;term := term + hilf;z1 := StrToInt(operandenStapel.erstes);operandenStapel.ohneErstes;z2 := StrToInt(operandenStapel.erstes);operandenStapel.ohneErstes;op := operatorenStapel.erstes;operatorenStapel.ohneErstes;if (op = '+') then erg := z2 + z1;if (op = '-') then erg := z2 - z1;if (op = '*') then erg := z2 * z1;if (op = ':') then erg := z2 div z1;ergebnis := IntToStr(erg);operandenStapel.mitErstem(ergebnis);
85
KB
List
en
LösungLösung
Fall 2: Das erste Element der TermSchlange ist ein Gleichheitszeichen und der OperatorenStapel ist leer:
=
5
'(7-2)'
''
hilf := termSchlange.erstes;termSchlange.ohneErstes;term := term + hilf;ergebnis := operandenStapel.erstes;
86
KB
List
en
LösungLösung
Fall 3: Das erste Element der TermSchlange ist „Klammerauf“:
( 7 - 2 ) =
''
''
hilf := termSchlange.erstes;termSchlange.ohneErstes;term := term + hilf;token := hilf;operatorenStapel.mitErstem(token);
87
KB
List
en
LösungLösung
Fall 4: Das erste Element der TermSchlange ist „Klammerzu“:
) =
(
-
7
'(7-2'
''
2
hilf := termSchlange.erstes;termSchlange.ohneErstes;term := term + hilf;z1 := StrToInt(operandenStapel.erstes);operandenStapel.ohneErstes;z2 := StrToInt(operandenStapel.erstes);operandenStapel.ohneErstes;op := operatorenStapel.erstes;operatorenStapel.ohneErstes;operatorenStapel.ohneErstes;if (op = '+') then erg := z2 + z1;if (op = '-') then erg := z2 - z1;if (op = '*') then erg := z2 * z1;if (op = ':') then erg := z2 div z1;token := IntToStr(erg);operandenStapel.mitErstem(token);
88
KB
List
en
LösungLösung
Fall 5: Das erste Element der TermSchlange ist ein Rechenzeichen:
- 2 ) =
(
7
'(7'
''
hilf := termSchlange.erstes;termSchlange.ohneErstes;term := term + hilf;token := hilf;operatorenStapel.mitErstem(token);
89
KB
List
en
LösungLösung
Fall 6: Das erste Element der TermSchlange ist eine Zahl:
2 ) =
(
-
7
'(7-'
''
hilf := termSchlange.erstes;termSchlange.ohneErstes;term := term + hilf;token := hilf;operandenStapel.mitErstem(token);
90
KB
List
en
LiteraturhinweiseLiteraturhinweise
Helmut Balzert: Lehrbuch Grundlagen der Informatik. Spektrum Ak. Verlag 1999.
H.-P. Gumm u. M. Sommer: Einführung in die Informatik. Oldenbourg Verlag 2002.
...