Grundkurs Informatik Aufgabensammlung mit Lösungen Teil 3

Grundkurs Informatik
Aufgabensammlung mit Lösungen
Teil 3: Kapitel 9 bis 14
H. Ernst
Die Aufgaben sind nach folgendem Schema klassifiziert:
T für Textaufgaben,
M für mathematisch orientierte Aufgaben,
L für Aufgaben, die logisches und kombinatorisches Denken erfordern,
P für Programmieraufgaben.
Nach der thematischen Kennung ist der Schwierigkeitsgrad der Aufgaben angegeben:
0 bedeutet „sehr leicht“. Diese Aufgaben können unmittelbar gelöst werden, ggf. mit etwas
Blättern im Buch.
1 bedeutet „leicht“ und kennzeichnet Aufgaben, die innerhalb von einigen Minuten mit wenig
Aufwand zu lösen sind.
2 bedeutet „mittel“. Solche Aufgaben erfordern etwas geistige Transferleistung und/oder einen
größeren Arbeitsaufwand.
3 bedeutet „schwer“ und ist für Aufgaben reserviert, die erheblichen Arbeitsaufwand mit kreativen
Eigenleistungen erfordern.
4 kennzeichnet „sehr schwere“ oder aufwändige Projekte.

3-2 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
9 Automatentheorie und formale Sprachen
9.1 Grundbegriffe der Automatentheorie
Aufgabe 9.1.1 (T1)
a) Was versteht man unter dem kartesischen Mengenprodukt?
b) Was ist ein Akzeptor?
c) Grenzen Sie die Begriffe Mealy- und Moore-Automat gegeneinander ab.
d) Was ist ein endlicher Übersetzer?
e) Definieren Sie den Begriff Mächtigkeit im Zusammenhang mit Automaten.
f) Was ist ein Fangzustand?
Lösung
a) Das kartesiche Mengenprodukt A×B zweier Mengen A und B ist die Menge aller geordneten
Paare der Art ab mit a∈A und b∈B. Ist beispielsweise A={x, y} und B={1, 2, 3}, dann
ist A×B = { x1, x2, x3, y1, y2, y3 }.
b) Ein Automat A(T,S,f) mit einem akzeptierten Sprachschatz L(A,sa,se) heißt Akzeptor oder
erkennender Automat. Eine Folge t∈T* von Eingabezeichen bringt den Automaten genau
vom Zustand sa in den Zustand se, wenn t∈L ist.
c) Hängt die Ausgabe eines Automaten A(T,S,Y,f) sowohl vom Eingabezeichen als auch
vom Zustand des Automaten ab, so nennt man den Automaten einen Mealy-Automaten:
g: T×S→Y
Hängt das Ausgabezeichen dagegen nur vom aktuellen internen Zustand des Automaten
ab, so bezeichnet man den Automaten als einen Moore-Automaten:
g: S→Y
d) Ein endlicher Übersetzer oder Transduktor ist ein endlicher, übersetzender Automat, der
durch einen endlichen Automaten A(T,S,Y,f) dargestellt wird. Der Automat ist endlich,
wenn T, S und Y endliche Mengen sind. Ein Transduktor transformiert (übersetzt) eine
eingegebene Zeichenkette t∈T* in eine Ausgabezeichenkette y∈T*. Davon zu unterscheiden
sind Akzeptoren, siehe Teilaufgabe b).
e) Bei einem Automaten mit endlichem Sprachschatz L wird die Anzahl der zu L gehörenden
Wörter als die Mächtigkeit |L| des Sprachschatzes bezeichnet. Ein Sprachschatz mit unendlich
vielen Wörtern hat die Mächtigkeit „abzählbar unendlich“. Allgemein bezeichnet
man als die Mächtigkeit einer Menge die Anzahl der Elemente der Menge.
f) Unter einem Fangzustand (oder Fehlerzustand) versteht man einen Zustand in einem
Automaten, der durch kein Eingabezeichen verlassen werden kann.

Aufgaben und Lösungen 2-3
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Aufgabe 9.1.2 (T1)
a) Wann nennt man eine Verknüpfung assoziativ?
b) Was versteht man unter einem Erzeugendensystem?
c) Was bedeutet Konkatenation?
d) Definieren Sie den Begriff Automorphismus.
e) Was ist die Worthalbgruppe?
f) Was ist eine induzierte Halbgruppe?
Lösung
a) Durch ° sei eine Verknüpfung in einer algebraischen Struktur A definiert. Die Verknüpfung
ist assoziativ, wenn gilt: (a ° b) ° c = a ° (b ° c) ∀ a,b,c∈A.
b) Es sei F eine Halbgruppe und E eine Unterhalbgruppe von F. Es sei die Kleene’sche Hülle
E* die Menge aller Elemente, die durch Verknüpfung beliebig vielen Elementen aus E entsteht.
Ist E*=F, so heißt Ein Erzeugendensystem von F. In diesem Sinne sind Alphabete
die Erzeugenden des zugehörigen Nachrichtenraums. Ein weiteres Beispiel sind die natürlichen
Zahlen N, für welche die nur die 1 enthaltende Teilmenge mit der Addition als
Verknüpfung ein Erzeugendensystem ist, da sich jede natürliche Zahl als eine Summe
von 1-en darstellen lässt.
c) Das Zusammenhängen von Wörtern aus einem Nachrichtenraum wird als Konkatenation
(Verkettung) bezeichnet.
d) Eine Abbildung ϕ: F→H mit Halbgruppen (Gruppen) F und H heißt Homomorhismus von F
in H, wenn gilt: ϕ(ab) = ϕ(a)ϕ(b) ∀ a,b∈F. Ist ϕ umkehrbar eindeutig, so spricht man von einem
Isomorphismus. Sind außerdem F und H identisch, so liegt ein Automorphismus vor.
e) Die Menge T* aller Wörter, die aus den Zeichen eines Alphabets T gebildet werden können,
ist eine als Worthalbruppe bezeichnete Halbgruppe mit der Konkatenation als Verknüpfung.
f) Die Menge aller Äquivalenzklassen bzw. Abbildungen eines Automaten A bildet mit der
Operation „hintereinander ausführen“ eine Halbgruppe. Diese wird als die durch A induzierte
Halbgruppe bezeichnet.
Aufgabe 9.1.3 (L2)
Gegeben sei der Automat mit T={a, b, c}
und S={sa ,s1, s2, se}, dessen Übergangsfunktion durch
die nebenstehende Tabelle definiert ist:
Es gilt: sa=Anfangszustand, se=Endzustand
a) Zeichnen Sie den Übergangsgraphen für diesen Automaten.
b) Welche der folgenden Wörter gehören zum akzeptierten
Sprachschatz dieses Automaten: abc, a 3 bc 3 , a 2 b 2 c 2 , a 3 b 2 c 2
Lösung
a) Übergangsdiagramm
sa
a,c
a
b
s1
c
a,b
b
b
s2
c
c
a
se
4
sa s1 s2 se
a s1 sa s1 se
b se s1 s1 sa
c s2 sa se s2

3-4 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
b) Der Automat befindet sich im Anfangszustand sa. Die Zeichen des Wortes abc werden nun
von links nach rechts zeichenweise eingegeben. Dabei ergeben sich folgende Übergänge:
saa→s1, s1b→s1, s1c→sa,
Insgesamt findet man also saabc→sa. Der Endzustand wird offenbar nicht erreicht, dementsprechend
gehört abc nicht zum akzeptierten Sprachschatz: abc∉L
Für a 3 bc 3 findet man: saa 3 bc 3 →se, also gilt a 3 bc 3 ∈L.
Für a 2 b 2 c 2 findet man: saa 3 bc 3 →se, also gilt a 2 b 2 c 2 ∈L.
Für a 3 b 2 c 2 findet man: saa 3 bc 3 →s2, also gilt a 3 b 2 c 2 ∉L.
Aufgabe 9.1.4 (L2)
Geben Sie den Übergangsgraphen und die Übergangstabelle eines endlichen Automaten mit
T={a, b} an, dessen akzeptierter Sprachschatz L aus der Menge aller Worte aus T* besteht,
die mit a beginnen und bb nicht als Teilstring enthalten. Formulieren Sie außerdem L in der
üblichen Mengenschreibweise.
a
Lösung
a sa
Se1
sa se1 se2 sf
a se1 se1 se1 sf
b
a b
b sf se2 sf sf
Einfache Lösung: L = {ax | x∈T*, bb∉x}
Besser: L = {a, (a ni b) m a k | ni∈N, m,k∈N0}
Aufgabe 9.1.5 (L3)
Geben Sie einen Automaten als Übergangstabelle und als Übergangsdiagramm an, der alle
aus den Ziffern 1 bis 4 gebildeten natürlichen Zahlen akzeptiert, deren Stellen monoton
wachsen (jede folgende Ziffer ist also größer oder gleich der vorangehenden). Ein Beispiel
ist etwa die Zahl 112444. Markieren Sie dabei den Anfangszustand und den Endzustand bzw.
die Endzustände.
Lösung
sa s1 s2 s3 s4 sf
1 s1 s1 sf sf sf sf
2 s2 s2 s2 sf sf sf
3 s3 s3 s3 s3 sf sf
4 s4 s4 s4 s4 s4 sf
Die Zustände s1 bis s4 sind alle Endzustände.
a,b
sa
sf
1
sf
1
s1
2
2
b
3
2
s2
se2
3
4
3
4
3
s3
4
4
4
s4

Aufgaben und Lösungen 2-5
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Aufgabe 9.1.6 (L4)
Gegeben sei der Automat A(T,S,f) mit T={a, b}, S={sa, se, sf } und
der durch die nebenstehende Tabelle definierten Zustandsübergangsfunktion f:
a) Zeichnen Sie den zugehörigen Zustandsübergangsgraphen.
b) Wie lautet der durch A akzeptierte Sprachschatz?
c) Bestimmen Sie die Äquivalenzklassen dieses Automaten.
d) Geben Sie die zugehörige induzierte Halbgruppe an.
e) Gibt es Null- und Einselemente in der induzierten Halbgruppe?
Lösung
a) Übergangsgraph:
a
a a, b
sa
b
se
b
sf
b) Der akzeptierte Sprachschatz lautet: L = { a n ba m | n,m∈N0 }
c) Die im Automaten möglichen Abbildungen lauten:
sa se sf Abbildung
a sa se sf* sa→sa, se→se, sf→sf
b se sf sf* sa→se, se→sf, sf→sf
aa sa se sf
ba se sf sf
ab se sf sf
bb sf sf sf* sa→sf, se→sf, sf→sf
aaa sa se sf
baa se sf sf
aba se sf sf
bba sf sf sf
aab sa se sf
bab sf sf sf
abb sf sf sf
bbb sf sf sf
Es gibt also drei Abbildungen, die zugehörigen Äquivalenzklassen lauten:
[a] = { a n | n∈N }
[b] = { a n ba m | n,m∈N0 } = L
[bb] = { x∈T*\[a]\[b] }
d) Die induzierte Halbgruppe lautet:
1.
2. [a] [b] [bb]
[a] [a] [b] [bb]
[b] [b] [bb] [bb]
[bb] [bb] [bb] [bb]
e) Es gibt ein Einselement, nämlich [a] und ein Nullelement, nämlich [bb].
sa se sf
a sa se sf
b se sf sf

3-6 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Aufgabe 9.1.7 (L3)
Beschreiben Sie ein Polynom soll als BNF-Produktion, als Syntax-Graph und als Automat.
Ein Polynom besteht aus durch die Operatoren + und – verknüpften Termen. Ein Term besteht
aus einer optionalen reellen Zahl, optional multipliziert mit einer beliebig langen Folge
von multiplikativ verknüpften Variablen x. Ein Term darf nicht leer sein.
Beispiele für Terme: 3.5, x, -5*x*x, x*x*x.
Beispiel für ein Polynom: 2 + 4*x + x*x*x - 3.5*x*x.
Die syntaktischen Variablen und dürfen für BNF-Produktionen und
Syntaxgraphen als bekannt vorausgesetzt werden. Das Alphabet des Automaten sei T={r, x,
*, +, -}, wobei r für eine reelle Zahl und x für eine Variable steht.
Lösung
::= |[{*}]
::= [{+|-}]
Term : Variable
sa
+, -, *
r, x, +, -, *
*
Reelle Zahl
+, -
r, x
r, x
se
sf s1
r, +, -, *
*
Polynom :
x
-
+
Term
sa s1 se sf
x se se sf sf
r se sf sf sf
* sf sf s1 sf
+, - sf sf sa sf

Aufgaben und Lösungen 2-7
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
9.2 Turing-Maschinen
Aufgabe 9.2.1 (T1)
a) Was haben Turing-Maschinen mit Berechenbarkeit zu tun?
b) Woran ist Alan Turing gestorben?
c) Was ist ein linear beschränkter Automat?
d) Grenzen Sie die Begriffe Automat, Kellerautomat und Turing-Maschine gegeneinander ab.
e) Was ist das Spiel des Lebens?
Lösung
a) Eine Funktion f(x)=y mit x,y∈T* ist Turing-berechenbar, wenn es eine Turing-Maschine
gibt, welche die auf dem Band gespeicherte Eingabe x in die Ausgabe y transformiert, die
dann auf dem Band abgelesen werden kann. Turing-Maschinen sind Modelle für einen
abstrakten Computer: alles was man prinzipiell mit einer Turing-Maschine berechnen
kann, kann man auch mit einem Computer berechnen und umgekehrt.
b) Alan Turing ist im Exil in Griechenland vermutlich durch Selbstmord an Gift gestorben. Er
musste England verlassen, da er wegen seiner offenkundig gewordenen Homosexualität
damals in einer geheimen militärischen Tätigkeit als Sicherheitsrisiko angesehen wurde.
c) Ein linear beschränkter Automat ist eine Turing-Maschine, bei der nur ein durch die Länge
des Eingabewortes beschränkter Bereich des Bandes verwendet wird. Die durch linear
beschränkte Automaten akzeptierten Sprachen sind zu den in Kapitel 9.3 eingeführten
kontextfreien Sprachen äquivalent, die eine wichtige Grundlage von Programmiersprachen
bilden.
d) Ein Automat hat außer den internen Zuständen keinen Speicher, er erhält von außen Eingabezeichen.
Ein Kellerautomat hat einen einseitig unbegrenzten Speicher, der als Stack für Kellerzeichen
verwendet wird. Er enthält ebenfalls von außen Eingabezeichen.
Eine Turing-Maschine hat ein beidseitig unbegrenztes lineares Speicherband, auf dem vor
Start der Turingmaschine die Eingabezeichen vorhanden sein müssen. Die Turingmaschine
kann dann die Zeichen vom Band lesen, Zeichen auf das Band schreiben und
schrittweise nach rechts und links den Schreib/Lese-Kopf auf dem Band bewegen.
e) John von Neumann beschäftigte sich seit Anfang der 50er Jahre mit zellulären Automaten,
die ebenfalls zur Simulation eines universellen Computers geeignet sind. Zunächst
ging es dabei nur um die formale Beschreibung der Fähigkeit zur Selbstreproduktion. Eine
populäre Variante zellulärer Automaten ist das Spiel des Lebens (Game of Life) von John
Conway (1968). Damit lassen sich interessante dynamische Strukturen generieren. Die
Regeln lauten:
• Ein rechteckiges Spielfeld, etwa ein Schachbrett, wird mit Spielmarken vorbesetzt.
• Jede Spielmarke mit zwei oder drei Nachbarn überlebt den aktuellen Spielschritt und
bleibt für die nächste Generation erhalten.
• Jede Spielmarke auf einem Feld mit vier oder mehr Nachbarn stirbt an Überbevölkerung,
d.h. sie wird in der nächsten Generation vom Spielfeld entfernt (gelöscht).
• Jede Spielmarke auf einem Feld mit nur einem oder gar keinem Nachbarn stirbt an Einsamkeit,
d.h. sie wird ebenfalls gelöscht.
• Auf jedem leeren, von genau drei Nachbarn umgebenen Feld, wird in der nächsten Generation
eine Spielmarke „geboren“. Alle anderen leeren Felder bleiben leer.

3-8 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Aufgabe 9.2.2 (L2)
Es sei die folgende Turing-Maschine mit
den Bandzeichen {0, 1} als Übergangsdiagramm gegeben.
a) Geben Sie das dazugehörige tabellarische
Turing-Programm an.
b) Der Schreib/Lese-Kopf stehe auf einem mit 0en
vorbesetzten Band. Was bewirkt diese Turing-Maschine?
Lösung
a)
1 0 1 R 2 2 0 1 L 1 3 0 1 L 2
1 1 L 3 1 1 R 2 1 1 R 0
1
1
1,L
3
1,L
0 1,R
1,L
0
2
1 1,R HAL
0
b) Diese Turing-Maschine schreibt 6 1en auf ein anfänglich mit 0en vorbesetztes Band. Sie
stoppt nach 13 Schritten unter der zweiten 1 von rechts.
Es handelt sich hierbei um die Busy-Beaver-Funktion bb(3), d.h. um diejenige aus genau
drei Anweisungen bestehende Turing-Maschine, welche die größte Anzahl von aufeinanderfolgenden
1en auf ein anfänglich mit 0en vorbesetztes Band schreibt.
Aufgabe 9.2.3 (L3)
Konstruieren Sie eine Turing-Maschine mit den Bandzeichen T={-,0,1}, welche für eine zusammenhängende
aus 0en und 1en bestehende Zeichenfolge auf einem mit - vorbesetzten Band
die Anzahl der 1en auf gerade Parität ergänzt. Dazu wird am linken Ende der Zeichenfolge eine
0 angefügt, wenn die Anzahl der 1en gerade ist und eine 1, wenn die Anzahl der 1en ungerade
ist. Der Schreib/Lese-Kopf soll vor der Operation rechts neben der Zeichenfolge stehen.
Beispiel: aus ----10101---- wird also ---110101---- und aus ----1001---- wird ---01001----
Lösung
Strategie:
1. In Zustand 1 rechts neben dem String starten.
In Zustand 1 nach links gehen, solange - gelesen wird.
Wird in Zustand 1 eine 0 gelesen, nach Zustand 3 gehen. (Erstes Stringzeichen ist 0)
Wird in Zustand 1 eine 1 gelesen, nach Zustand 2 gehen. (Erstes Stringzeichen ist 1)
2. In Zustand 2 solange nach links gehen, wie 0en gelesen werden.
Wird in Zustand 2 eine 1 gelesen, nach Zustand 3 gehen.
Wird in Zustand 2 ein - gelesen, ist das Stringende erreicht, eine 1 schreiben, HALT.
3. In Zustand 3 solange nach links gehen, wie 0en gelesen werden.
Wird in Zustand 3 eine 1 gelesen, nach Zustand 2 gehen.
Wird in Zustand 3 ein - gelesen, ist das Stringende erreicht, eine 0 schreiben, HALT.
Ist die Turing-Maschine in Zustand 2, so ist die aktuelle Anzahl der 1en ungerade, ist sie in
Zustand 3, so ist die Anzahl der 1en gerade.
- - L 1 - 1 L 0 - 0 L 0
1 0 0 L 3 2 0 0 L 2 3 0 0 L 3
1 1 L 2 1 1 L 3 1 1 L 2
1
1,R

Aufgaben und Lösungen 2-9
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
0,L
0
-
0
0,L
-,L
1
3
1
1
-
1,L
Aufgabe 9.2.4 (L3)
1,L
0,L
1,L
0
1
0,L
2
HALT
-
1,L HALT
Konstruieren Sie eine Turing-Maschine mit den Bandzeichen T={-,0,1}, die in einer zusammenhängenden
Gruppe von Einsen auf einem mit Strichen vorbesetzten Band zwischen je
zwei Einsen eine Null einfügt. Zu Beginn soll der Schreib-/Lesekopf rechts von der Einsergruppe
stehen. Beispiel: aus ------11111----- wird also ------101010101-----
Lösung
Strategie:
1. In Zustand 1 rechts neben dem String starten.
In Zustand 1 nach links gehen, bis zur ersten 1, also zum String-Anfang.
Wurde die erste 1 gelesen, nach Zustand 2 gehen.
2. In Zustand 2 einen Schritt nach links gehen.
Wird dort eine 1 gelesen, diese durch 0 ersetzen und nach Zustand 3 gehen.
Wird ein - oder eine 0 gelesen, HALT.
3. In Zustand 3 solange nach links gehen, bis ein - gelesen wird.
Den - am Stringende durch eine 1 ersetzen und nach Zustand 4 gehen.
4. In Zustand 4 nach rechts gehen bis eine 0 gelesen wird.
Jetzt weiter bei Punkt 1 in Zustand 1.
- - L 1 - - R 0 - 1 R 4 - - R 0
1 0 0 L 0 2 0 0 L 0 3 0 0 L 3 4 0 0 L 1
1 1 L 2 1 0 L 3 1 1 L 3 1 1 R 4
HALT
-,R
-
-
-,L
0,L
0
1
4
1,R
0
1
HALT
0,L
1
1,L
1,R
-
1
0,L
2
3
0,L
1
0
- -,R
HALT
0 0,L
1,L

3-10 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
9.3 Einführung in die Theorie der formalen Sprachen
Aufgabe 9.3.1 (T1)
a) Wie kann man endliche von zyklischen Sackgassen unterscheiden?
b) Wann ist eine formale Sprache eindeutig?
c) Was ist ein Palindrom?
d) Was versteht man unter einer kontextfreien Sprache?
e) Was ist das Wortproblem?
Lösung
a) Kommt man bei der Analyse eines Wortes nach endlich vielen Schritten zu einem Wort,
auf das keine Produktionen mehr angewendet werden können, so ist man in eine endliche
Sackgasse geraten. Man kann dann die Analyse bei einer vorangehenden Verzweigungsmöglichkeit
wieder aufnehmen. Bei einer zyklischen Sackgasse führt die Analyse
nach einer endlichen Anzahl von Schritten wieder auf ein Wort, das in einem früheren
Schritt bereits aufgetreten ist. Man kann die Sackgasse erkennen und wieder verlassen,
wenn man alle Analyseschritte zwischenspeichert und immer wieder mit dem aktuellen
Schritt vergleicht.
b) Eine formale Sprache heißt eindeutig, wenn der zugehörige Sprachschatz eindeutig ist,
d.h. wenn alle zum Sprachschatz gehörenden Wörter nur auf eine einzige, eindeutige
Weise aus dem Axiom Z ableitbar sind.
c) Unter einem Palindrom versteht man ein um seinen Mittelpunkt symmetrisches Wort. Es
ist also vorwärts und rückwärts gelesen identisch. Beispiel: otto.
d) Eine Grammatik heißt kontextfrei (context free) oder Chomsky-2-Grammatik, wenn die
Produktionen nicht von einem Kontext abhängen. Die Produktionen haben dann die einfache
Form:
A→u mit A∈S und u∈V*\{ε}
Die syntaktische Variable A wird also unabhängig von rechts oder links benachbarten
Zeichen, dem Kontext, in ein beliebiges, nichtleeres Wort aus V* transformiert. Worte
können also nicht kürzer werden, d.h. die Sprache ist wortlängenmonoton. Die Menge der
durch kontextfreie Grammatiken erzeugten Sprachen ist mit der Menge der durch Kellerautomaten
akzeptierten Sprachen identisch.
e) Unter dem Wortproblem versteht man die Aufgabe, von einem gegebenen Wort zu entscheiden,
ob es zu einem bestimmten Sprachschatz gehört oder nicht. Es kann sich dabei
beispielsweise um den Sprachschatz einer formalen Sprache oder um den akzeptierten
Sprachschatz eines Automaten handeln.
Aufgabe 9.3.2 (T1)
a) Was versteht man unter dem Nachbereich einer formalen Sprache?
b) Unter welcher Bedingung heißt eine Produktion terminal?
c) Was versteht man unter dem Kern einer formalen Sprache?
d) Welche Klasse von formalen Sprachen der Chomsky-Hierarchie lässt sich durch
Automaten darstellen?
e) Welcher Typ von formalen Sprachen ist zu Kellerautomaten äquivalent?

Aufgaben und Lösungen 2-11
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Lösung
a) Unter dem Nachbereich einer formalen Sprache versteht man die Menge aller Wörter, die
aus dem Axiom Z∈S ableitbar sind.
b) Eine Produktion heißt terminal, wenn das Ergebnis nur aus terminalen Zeichen besteht,
also:
u→v ist terminal, wenn v∈T*\{ε}
Im engeren Sinne verlangt man noch Wortlängenmonotonie. Bei regulären Sprachen ist
außerdem u∈S vorausgesetzt, d.h. u muss eine syntaktische Variable sein.
c) Der Kern einer formalen Sprache besteht aus allen aus dem Axiom Z ableitbaren Wörtern,
aus denen sich die Wörter des Sprachschatzes (also die Menge aller ausschließlich aus
terminalen Zeichen bestehenden Wörter) ableiten lassen. Zusätzlich zum Sprachschatz
umfasst der Kern also auch Worte, in denen auch Syntaktische Variablen enthalten sind.
d) Reguläre Grammatiken, also solche mit terminalen und linkslinearen oder rechtslinearen
Produktionen, lassen sich durch Automaten darstellen.
e) Kontextfreie Sprachen, also Chomsky-2-Grammatiken sind zum akzeptierten Sprachschatz
von Kellerautomaten äquivalent.
Aufgabe 9.3.2 (T1)
Gegeben sei die folgende formale Sprache:
S = {Z, X}, T = {u, v, w}, P = { Z→uZv, Z→X, X→vXu, X→v, X→w }
a) Von welchem Typ ist die Grammatik?
b) Geben Sie den zugehörigen Sprachschatz an.
c) Leiten Sie das Wort uv 2 wu 2 v aus dem Axiom ab. Falls es bei der Ableitung Sackgassen
gibt, geben Sie bitte ein Beispiel an.
Lösung
a) Die Sprache ist wortlängenmonoton, da keine Produktion verkürzend wirkt. Sie ist außerdem
kontextfrei und daher vom Typ Chomsky-2. Da es nichtlineare Produktionen gibt, ist
die Sprache nicht vom Typ Chomsky-3.
b) Der zugehörige Sprachschatz lautet: L={ u n v m xu m v n | n,m ∈N0, x={v,w} }.
Die kürzesten Wörter sind: v, w, uwv, uv 2 .
c) Z→uZv→uvXuv→uvvXuuv→uv 2 wu 2 v
Es gibt Sackgassen, aber nur endliche. Beispiel: Z→uZv→uvXuv→uvwuv
Aufgabe 9.3.2 (T1)
Konstruieren Sie eine Formale Sprache L für die Menge aller korrekten arithmetischen Ausdrücke
mit natürlichen Zahlen n unter Verwendung der Operationen „+“ und „ * “ sowie der üblichen
Klammerung.
Lösung
T={0, 1, 2, 3, 4, 5, 6, 7, 8, 9, +, *, (, )}
S={Z, N, T}
P={Z→T, T→T+T, T→T*T, T→(T), T→N, N→NN, N→0,1..9 }

3-12 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Aufgabe 9.3.2 (T1)
Die Zusammenstellung eines Intercity-Zuges möge nach folgenden Regeln erfolgen:
Der erste Wagen des Zugs ist ein Triebwagen, es folgen n>1 Wagen der ersten Klasse, danach
folgt ein Speisewagen und danach 2n Wagen der zweiten Klasse.
a) Geben Sie die Wagenfolge des kürzestmöglichen Zuges an.
b) Konstruieren Sie eine formale Sprache für die Zusammenstellung von Intercity-Zügen.
Verwenden Sie dazu die Menge T={t,1,s,2} von terminalen Zeichen in ihrer offensichtlichen
Bedeutung sowie die Menge S={Z,W} von syntaktischen Variablen, wobei W
für „Wagen“ steht.
c) Von welchem Chomsky-Typ ist diese Sprache? Bitte begründen Sie Ihre Antwort.
d) Wie muss man die Regeln für die Zugzusammenstellung ändern, damit die entsprechende
formale Sprache als Automat darstellbar ist?
Lösung
a) Mit T={t,1,s,2} lautet die Wagenfolge des kürzestmöglichen
ICE-Zuges: t1s22
b) Vokabular: V = T∪S mit T={t,1,s,2} und S={Z, W}
Produktionen: P = {Z→tW, W→1s22, W→1W22}
c) Nicht alle verwendeten Produktionen sind terminal oder linear, daher ist die Sprache nicht
CH-3. Die Sprache ist wortlängenmonoton und kontextfrei und daher vom Typ CH-2.
d) Problematisch ist, dass die Anzahl der Wagen zweiter Klasse doppelt so hoch sein soll wie
die der ersten Klasse und dass die Anzahl der Wagen nicht beschränkt ist. Beschränkt man
die Anzahl der Wagen, so ist eine Darstellung als Automat möglich. Auch ohne Beschränkung
gelingt dies, wenn die Anzahl der Wagen erster Klasse unabhängig von der Anzahl der
Wagen zweiter Klasse ist.
Man kann zwar eine Mengen von Produktionen finden, bei der alle Produktionen terminal
oder linear sind, beispielsweise
P = {Z→tW, W→1s22, W→V22, V→1W}
es treten jedoch linkslineare und rechtslineare Produktionen auf, so dass die resultierende
Grammatik nicht regulär ist.
Man könnte die Aufgabe jedoch ohne weiteres mit Hilfe eines Kellerautomaten lösen.

Aufgaben und Lösungen 2-13
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
10 Algorithmen
10 Algorithmen
Aufgabe 10.1 (T1)
a) Wann ist ein Algorithmus statisch finit und wann dynamisch finit?
b) Erläutern Sie den Unterschied zwischen Berechenbarkeit und Komplexität.
c) Was besagt die Church-Turing-These?
d) Was ist der Unterschied zwischen primitiv-rekursiven und µ-rekursiven Funktionen?
e) Was sind NP-vollständige Probleme
f) Wann ist ein Algorithmus effektiv, wann effizient?
Aufgabe 10.2 (T1)
a) Was ist eine rekursive Relation?
b) Wodurch unterscheiden sich probabilistische und heuristische Algorithmen?
c) Was ist ein genetischer Algorithmus?
d) Erläutern Sie das Prinzip des Backtracking.
e) Erläutern Sie das Prinzip Teile und Herrsche.
f) Was ist ein gieriger Algorithmus?
Aufgabe 10.3 (M3)
Die Ackermann-Funktion.
a) Wie ist die Ackermann-Funktion definiert?
b) Ist die Ackermann-Funktion primitiv-rekursiv?
c) Berechnen Sie ack(3,2)
d) Für welches x∈N gilt ack(3,ack(0,y)) = ack(x,ack(3,y)) ?
e) Zeigen Sie: ack(p,q+1) > ack(p,q)
Lösung
a) Die Ackermann-Funktion ack(x,y) ist folgendermaßen rekursiv definiert:
ack(0,y) = y+1
ack(x+1,0) = ack(x,1)
ack(x+1,y+1) = ack(x,ack(x+1,y)
b) Die Ackermann-Funktion ist keine primitiv-rekursive Funktion, sondern eine µ-rekursive
Funktion, da man zeigen kann, dass sie schneller wächst als jede primitiv rekursive Funktion.
Sie ist jedoch berechenbar, da sie eine µ-rekursive Funktion ist.
Man kann auch als Begründung angeben, dass man bei der iterativen Programmierung
der Ackermann-Funktion nicht mit einer klassischen FOR-Schleife auskommt. Man benötigt
eine GOTO oder eine WHILE-Schleife.
c) Im Folgenden wird statt ack(a,b) vereinfachend (a,b) geschrieben.
Nach dem Aufschreiben der ersten Terme erkennt man das Bildungsgesetz, so dass sich
die Lösung schnell finden lässt. Siehe auch Aufgabe 10.4.
(3,2) = (2,(3,1)) = (2,(2,(3,0))) = (2,(2,(2,1))) =
(2,(2,(1,(2,0)))) = (2,(2,(1,(1,1)))) = (2,(2,(1,(0,(1,0))))) =
(2,(2,(1,(0,(0,1))))) = (2,(2,(1,(0,2)))) = (2,(2,(1,3))) =
(2,(2,(0,(1,2)))) = (2,(2,(0,(0,(1,1))))) = (2,(2,(0,(0,(0,(1,0)))))) =
(2,(2,(0,(0,(0,2))))) = (2,(2,(0,(0,3)))) = (2,(2,(0,4))) = (2,(2,5)) =

3-14 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
(2,(1,(2,4))) = (2,(1,(1,(2,3)))) = (2,(1,(1,(1,(2,2))))) = (2,(1,(1,(1,(1,(2,1)))))) =
(2,(1,(1,(1,(1,(1,(2,0))))))) =
(2,(1,(1,(1,(1,(1,(1,1))))))) =
(2,(1,(1,(1,(1,(1,(0,(1,0)))))))) =
(2,(1,(1,(1,(1,(1,(0,(0,1)))))))) =
(2,(1,(1,(1,(1,(1,(0,2))))))) =
(2,(1,(1,(1,(1,(1,3)))))) =
(2,(1,(1,(1,(1,(0,(1,2))))))) =
(2,(1,(1,(1,(1,(0,(0,(1,1)))))))) =
(2,(1,(1,(1,(1,(0,(0,(0,(1,0))))))))) =
(2,(1,(1,(1,(1,(0,(0,(0,(0,1))))))))) =
(2,(1,(1,(1,(1,(0,(0,(0,2)))))))) =
(2,(1,(1,(1,(1,(0,(0,3))))))) =
(2,(1,(1,(1,(1,(0,4)))))) =
(2,(1,(1,(1,(1,5))))) =
(2,(1,(1,(1,(0,(1,4)))))) =
(2,(1,(1,(1,(0,(0,(1,3))))))) =
(2,(1,(1,(1,(0,(0,(0,(1,2)))))))) =
(2,(1,(1,(1,(0,(0,(0,(0,(1,1))))))))) =
(2,(1,(1,(1,(0,(0,(0,(0,(0,(1,0)))))))))) =
(2,(1,(1,(1,(0,(0,(0,(0,(0,(0,1)))))))))) =
(2,(1,(1,(1,(0,(0,(0,(0,(0,2))))))))) =
(2,(1,(1,(1,(0,(0,(0,(0,3)))))))) =
(2,(1,(1,(1,(0,(0,(0,4))))))) =
(2,(1,(1,(1,(0,(0,5)))))) =
(2,(1,(1,(1,(0,6))))) =
(2,(1,(1,(1,7)))) =
(2,(1,(1,(0,(1,6))))) =
…
(2,(1,(1,(0,(0,(0,(0,(0,(0,(0,(1,0))))))))))) =
(2,(1,(1,(0,(0,(0,(0,(0,(0,(0,(0,1))))))))))) =
…
(2,(1,(1,(0,8)))) =
(2,(1,(1,9))) =
(2,(1,(0,(1,8)))) =
…
(2,(1,(0,(0,(0,(0,(0,(0,(0,(0,(0,(1,0)))))))))))) =
(2,(1,(0,(0,(0,(0,(0,(0,(0,(0,(0,(0,1)))))))))))) =
…
(2,(1,(0,10))) =
(2,(1,11)) =
(2,(0,(1,10))) =
…
(2,(0,(0,(0,(0,(0,(0,(0,(0,(0,(0,(0,(1,0))))))))))))) =
(2,(0,(0,(0,(0,(0,(0,(0,(0,(0,(0,(0,(0,1))))))))))))) =
…
(2,(0,12)) =
(2,13) =
(1,(2,12)) =
(1,(1,(2,11))) =
(1,(1,(1,(2,10)))) =
(1,(1,(1,(1,(2,9))))) =
(1,(1,(1,(1,(1,(2,8)))))) =
(1,(1,(1,(1,(1,(1,(2,7))))))) =
(1,(1,(1,(1,(1,(1,(1,(2,6)))))))) =
(1,(1,(1,(1,(1,(1,(1,(1,(2,5))))))))) =

Aufgaben und Lösungen 2-15
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
(1,(1,(1,(1,(1,(1,(1,(1,(1,(2,4)))))))))) =
(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(2,3))))))))))) =
(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(2,2)))))))))))) =
(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(2,1))))))))))))) =
(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(2,0)))))))))))))) =
(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,1)))))))))))))) =
(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(0,(1,0))))))))))))))) =
(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(0,(0,1))))))))))))))) =
(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(0,2)))))))))))))) =
(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,3))))))))))))) =
(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(0,(1,2)))))))))))))) =
(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(0,(0,(1,1))))))))))))))) =
(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(0,(0,(0,(1,0)))))))))))))))) =
(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(0,(0,(0,(0,1)))))))))))))))) =
(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(0,(0,(0,2))))))))))))))) =
(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(0,(0,3)))))))))))))) =
(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(0,4))))))))))))) =
(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,5)))))))))))) =
…
(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,7))))))))))) =
…
(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,9)))))))))) =
…
(1,(1,(1,(1,(1,(1,(1,(1,(1,11))))))))) =
…
(1,(1,(1,(1,(1,(1,(1,(1,13)))))))) =
…
(1,(1,(1,(1,(1,(1,(1,15))))))) =
…
(1,(1,(1,(1,(1,(1,17)))))) =
…
(1,(1,(1,(1,(1,19))))) =
…
(1,(1,(1,(1,21)))) =
…
(1,(1,(1,23))) =
…
(1,(1,25)) =
…
(1,27) =
…
29
d) ack(3,ack(0,y)) = ack(3,y+1) = ack(2+1,y+1) = ack(2,ack(3,y))
Es ist also x=2
e) q0, q>1 (*)
A(p,q)1
p>1, q=0: A(p,0)=0 < A(0,1)=2

3-16 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Aufgabe 10.4 (P3)
Schreiben sie ein rekursives und ein iteratives Programm zur Berechnung der Ackermann-
Funktion. Vergleichen Sie die Ausführungszeiten.
Lösung
//***********************************************************************
// Vergleich der rekursiven und iterativen
// Berechnung der Ackermann-Funktion
//***********************************************************************
#include
#include
#include
#define SMAX 100000
//***********************************************************************
// Iterative Berechnung der Ackermann-Funktion
//-----------------------------------------------------------------------
int ak_i(int x, int y) {
int k, s[SMAX+2], sp=0; // Stack und Stack-Pointer
s[sp++]=x; s[sp++]=y; // x und y in Stack eintagen
while(sp!=1){
//printf("\nS:"); for(k=0; k=SMAX) return -1; // Stack-Überlauf
}
return s[--sp]; // Ergebnis: letzter Stack-Eintrag
}
//***********************************************************************
// Rekursive Berechnung der Ackermann-Funktion
//-----------------------------------------------------------------------
int ak_r(int x, int y) {
if(x==0) return(y+1); // Abbruchkriterium
if(y==0) return(ak_r(x-1,1)); // einfache Rekursion
return(ak_r(x-1,ak_r(x,y-1))); // doppelte Rekursion
}
//***********************************************************************
// Hauptprogramm
//***********************************************************************
int main() {
int x=1,y=1, a=0; // Parameter deklarieren und vorbesetzen
time_t t; // Zeit
printf("\n\nACKERMANN-FUNKTION\n");
while(x>0 && y>0) { // Solange x und y nicht 0 sind
printf("\nx, y = ");
scanf("%d,%d",&x,&y); // Eingabe von x und y
t=clock(); // Anfangszeit merken
printf("\nak_r = %d ",ak_r(x,y)); // ak(x,y) rekursiv
printf("(%5.2f sec)\n",(float)difftime(clock(),t)/CLOCKS_PER_SEC);
t=clock(); // Anfangszeit merken
a=ak_i(x,y); // ak(x,y) iterativ
if(a

Aufgaben und Lösungen 2-17
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Aufgabe 10.4 (M2)
Beweisen Sie durch vollständige Induktion:
n
n
3
i = i
⎛
⎜
⎝
∑ ∑
i=
1 i=
1
Lösung
⎞
⎟
⎠
Aufgabe 10.5 (M2)
2
Der übliche Algorithmus zur Multiplikation zweier n×n-Matrizen hat die Komplexität O(n 3 ). Nach
dem Verfahren von Strassen lassen sich zwei n×n-Matrizen mit der Komplexität O(n ld(7) ) multiplizieren.
Für n=10 benötige der übliche Algorithmus auf einem bestimmten Rechner 0.1 Sekunden
und der Strassen-Algorithmus 0.12 Sekunden.
a) Um wie viele Sekunden arbeitet der Strassen-Algorithmus schneller als der übliche Algorithmus,
wenn n=100 ist?
b) Wie groß muss n sein, damit der Strassen-Algorithmus auf dem gegebenen Rechner doppelt
so schnell abläuft wie der konventionelle Algorithmus?
Lösung
a) TM = cM⋅n 3 konventioneller Algorithmus
TM(10) = cM⋅10 3 sec = 0.1 sec, also cM=0.1/1000=10 -4
TM(100) = 10 -4 ⋅100 3 sec = 100 sec
TS = cS⋅n ld(7) = cS ⋅n 2.807
TS(10) = cS⋅10 2.807 sec = 0.12 sec, also cS≈0.12/641.21 ≈ 1.87⋅10 -4
TS(100) = 1.87⋅10 -4 ⋅100 2.807 sec ≈ 1.87⋅10 -4 ⋅4.1115⋅10 5 sec ≈ 76.9sec
Strassen-Algorithmus
Differenz: D = TM(100)-TS(100) = (100-76.9) sec = 23.1 sec
Für n=100 arbeitet der Strassen-Algorithmus also um 23.1 sec schneller als der konventionelle
Algorithmus.
b) cM⋅n 3 = 2⋅ cS⋅n 2.807
n 3-2.807 = n 0.193 = 2⋅ cS/cM = 2⋅1.87⋅10 -4 /10 -4 = 3.74
n = 3.74 1/0.193 ≈ 3.74 5.1813 ≈ 929
Erst für n=929 arbeitet der Strassen-Algorithmus doppelt so schnell wie der konventionelle
Algorithmus.

3-18 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
11 Suchen und Sortieren
11.1 Einfache Suchverfahren
Aufgabe 11.6.1 (T1)
a) Was ist eine Marke im Zusammenhang mit Suchen in Arrays?
b) Ist Suchen in Arrays oder in linearen Listen effizienter durchführbar?
c) Was versteht man unter Radix-Suche?
d) Wodurch unterscheiden sich die sequentielle und die binäre Suche?
Lösung
Aufgabe 11.6.2 (P3)
Vergleich von binärer Suche und Interpolationssuche.
• Erstellen Sie ein Array a[] mit 30 000 Integer-Zufallszahlen. Verwenden Sie dabei die
Uhrzeit als Startwert für den Zufallszahlengenerator.
• Ordnen Sie das Array in aufsteigender Folge mit einer beliebigen Sortierfunktion.
• Schreiben Sie eine Funktion search_bin zum binären Suchen. Suchen Sie damit in einer
eine Million mal durchlaufenen Schleife nach zufällig ausgewählten Zahlen und geben Sie
die mittlere Anzahl der Intervallteilungen sowie die mittlere Ausführungszeit aus.
• Schreiben Sie eine Funktion search_int zur Interpolationssuche. Suchen Sie damit in
einer mindesten 1 Million mal durchlaufenen Schleife nach denselben Zufallszahlen wie mit
der binären Suche und geben Sie auch dafür die mittlere Anzahl der Intervallteilungen sowie
die benötigte Ausführungszeit aus. Warnung: es ist auf effiziente Implementierung und
auf Rundungsfehler bei der Intervallteilung zu achten.
• Vergleichen und interpretieren Sie die Ergebnisse für die binäre Suche und die Interpolationsuche.
Lösung
//************************************************************************
// Vergleich der binären Suche und der Interpolationssuche
//************************************************************************
#include
#include
#include
#define MAX 30000
#define ESC 27
void sort_insb(long int a[], long int n);
long int srch_int(long int x, long int a[], long int n);
long int srch_bin(long int x, long int a[], long int n);
int count;
//------------------------------------------------------------------------
// Vergleich der binären Suche und der Interpolationssuche durch Suche
// in einem mit Zufallszahlen vorbesetzten und danach geordneten Feld.
//------------------------------------------------------------------------
int main() {
long int c=0, i, k, a[MAX], n=MAX, m=100;
float sum;

Aufgaben und Lösungen 2-19
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
}
time_t t; // Zeit
printf("\nVergleich von Suchalgorithmen");
printf("\n=============================");
srand((unsigned)time(NULL)); // init. Zufallszahlengenerator
while(c!=ESC) {
for(i=0; i

3-20 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
}
long int anf=0, end=n-1, m=0; // Intervall
count=0; // Schrittzähler
if(xa[end])
return -1; // Element zu klein oder zu groß
while(anf

Aufgaben und Lösungen 2-21
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
11.3 Gestreute Speicherung (Hashing)
Aufgabe 11.3.1 (T1)
a) Was ist der wesentliche Vorteil von Hash-Verfahren?
b) Was versteht man unter Klumpenbildung?
c) Nennen Sie einen Vorteil und einen Nachteil der quadratischen im Vergleich zur linearen
Kollisionsauflösung.
d) Welche Forderungen stellt man üblicherweise an Hash-Funktionen?
e) Wie ist der Belegungsfaktor definiert?
f) Kann der Belegungsfaktor größer als 1 werden?
Lösung
a) Rascher Zugriff auf die Datensätze mit wenig Schlüsselvergleichen auch bei großen Datenmengen.
b) Wenn durch die Kollisionsauflösung Häufungen von Einträgen im Adressraum entstehen,
spricht man von Klumpenbildung. Die lineare Kollisionsauflösung neigt zur Klumpenbildung.
Der Nachteil ist, dass in Klumpen eine erhöhte Anzahl von Schlüsselvergleichen erforderlich
ist.
c) Die quadratische Kollisionsauflösung verteilt die Einträge gleichmäßiger über den Adressraum,
die Klumpenbildung ist also geringer. Die Größe des Adressraums muss eine Primzahl
sein, aber auch dann wird von einer bestimmten Primäradresse ausgehend nur die
hälfte des Adressraums erfasst.
d)
- Die Hash-Funktion soll schnell aus dem Primärschlüssel berechnet werden können.
- Ein bestehende Ordnung der Primärschlüssel soll erhalten bleiben.
- Die Hash-Funktion soll die Adressen gleichmäßig über die m möglichen Adressen verteilen.
- Alle Schlüssel sollen mit gleicher Wahrscheinlichkeit auftreten.
- Die durch die Kollisionsbehandlung berechneten Adressen sollen gleichmäßig über den
Adressraum verteilt werden.
e) Der Belegungsfaktor lautet µ=n/m, wobei n die Anzahl der gespeicherten Datensätze ist
und m der Umfang des Adressraums.
f) Der Belegungsfaktor kann größer als 1 werden, wenn die Anzahl der gespeicherten Datensätze
die Größe des Adressraums übersteigt. Dies kann dann der Fall sein, wenn der
Adressraum nur für die Primäradressen gilt, der Speicherplatz für die Kollisionsauflösung
aber durch dynamische Speicherplatzzuweisung erfolgt, beispielsweise bei Kollisionsauflösung
durch lineare Listen.

3-22 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Aufgabe 11.3.2 (M1)
Berechnen Sie die mittlere Anzahl S von Vergleichen zum Auffinden eines beliebigen Datensatzes
in einer Hash-Tabelle, die maximal 100 000 Datensätze enthalten kann und bereits
mit 86 000 Datensätzen gefüllt ist. Dabei kann von idealen Bedingungen ausgegangen werden.
Lösung
1 ⎛ 1 ⎞
Für ideale Verhältnisse gilt: S = ln⎜
⎟
μ ⎝1
− μ ⎠
Mit µ=n/m=86000/100000=0.86 folgt: S=1.16279·ln(7.14286)=2.28618. Es sind also im Mittel etwas
mehr als zwei Vergleiche erforderlich.
Aufgabe 11.3.3 (M2)
Es soll eine Hash-Tabelle mit einem Adressraum von m=13 angelegt werden. Die Hash-
Funktion sei definiert durch die Vorschrift:
h(Name) = [pos(1. Buchstabe) + pos(2. Buchstabe) ] mod 13
Dabei gibt pos() die Position des betreffenden Buchstaben im Alphabet an, also pos(A)=1 etc.
a) Geben Sie den Belegungsfaktor an.
b) Tragen Sie die folgenden Datensätze in der angegebenen Reihenfolge unter Verwendung
der linearen und der quadratischen Kollisionsauflösung in die Hash-Tabelle ein:
Hammer, Feile, Nagel, Zange, Zwinge, Raspel, Schraube, Niete, Pinsel
c) Berechnen Sie die mittlere Anzahl der Vergleiche für erfolgreiche und erfolglose Suche.
Lösung
1 Hammer, 2 Feile, 3 Nagel, 4 Zange, 5 Zwinge, 6 Raspel, 7 Schraube, 8 Niete, 9 Pinsel,
8+1 6+5 14+1 26+1 26+23 18+1 19+3 14+9 16
9 11 2 1 10 6 9 10 3
Hash-Adresse Name (linear) Name (quadr.)
_____________________________________________________________________
1 4 Zange 4 Zange
2 3 Nagel 3 Nagel
3 9 Pinsel 9 Pinsel
4 --- ---
5 --- ---
6 6 Raspel 6 Raspel
7 --- 8 Niete
8 --- ---
9 1 Hammer 1 Hammer
10 5 Zwinge 5 Zwinge
11 2 Feile 2 Feile
12 7 Schraube ---
13 8 Niete 7 Schraube
Quadr. Kollisionsaufl.: h+1, h+4, h+9, etc.

Aufgaben und Lösungen 2-23
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Aufgabe 11.3.4 (P3)
Es soll eine Datenverwaltung unter Verwendung der gestreuten Speicherung aufgebaut werden.
Die Primäradresse A soll dabei möglichst einfach unter Einhaltung der lexikografischen
Ordnung aus dem Primärschlüssel der Datensätze berechnet werden. Die Kollisionsbehandlung
soll mit Hilfe einfach verketteter nach dem Primärschlüssel geordneter linearer Listen
erfolgen. Es sollen die Operationen Einfügen, Suchen, Löschen und Auflisten von Datensätzen
realisiert werden.
Lösung
//*************************************************
//
// Hashing mit Überlaufbehandlung
// durch verketteten Listen
//
//*************************************************
#include
#include
#include
#define DIM 20
#define ANZ 100
int eingabe(char text[], int l);
int auflisten(void);
int einfuegen(void);
int hash(char *text);
int suchen(void);
int loeschen(void);
struct rec { // Datensatz
char info[DIM]; // Informationsteil
struct rec *pnt; // Zeiger
};
struct rec *hfeld[ANZ]; // Hash-Feld, Zeiger
//**************************************************
// Eingabefunktion mit Überlaufsicherung
//--------------------------------------------------
int eingabe(char text[], int len) {
int i=0, e=0, c=1;
if(len>=DIM) { len=DIM-1; e=-1; } // Maximallänge
while(i

3-24 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
}
//**************************************************
// Auflisten der Daten
//--------------------------------------------------
int auflisten(void) {
int i, e=-1;
struct rec *pnt;
printf("\nDatensätze:\n");
for(i=0; iinfo);
pnt=pnt->pnt;
}
}
}
if(e) { printf("Datei ist leer!\n"); return(-1); }
printf("\n");
return(0);
}
//**************************************************
// Suchen eines Datensatzes
//--------------------------------------------------
int suchen(void) {
char text[DIM];
struct rec *pnt;
printf("\nGeben Sie den Datensatz ein: ");
eingabe(text,DIM); // Zu suchender Datensatz
pnt=hfeld[hash(text)]; // Primäradresse
while(strcmp(text,pnt->info) && pnt) pnt=pnt->pnt;
if(pnt!=NULL) printf("\nGefunden: %s\n",pnt->info);
else printf("\nNicht gefunden: %s\n",text);
return(0);
}
//**************************************************
// Einfügen eines Datensatzes
//--------------------------------------------------
int einfuegen(void) {
char text[DIM];
int i;
struct rec *neu, *pnt, *vor;
printf("\nEingabe, beenden mit ");
for(;;) {
printf("\n> "); // Prompt
eingabe(text,DIM); // Eingabe
if(text[0]==0) return(0); // Eingabe beenden
i=hash(text); // Primäradresse
pnt=vor=hfeld[i];
neu=(struct rec *)malloc(sizeof(struct rec));
strcpy(neu->info,text);
if(strcmp(text,pnt->info)pnt=hfeld[i]; // Neue Wurzel
hfeld[i]=neu;
}
else {
while(strcmp(text,pnt->info)>0 && pnt) {
vor=pnt; // Einfügestelle

Aufgaben und Lösungen 2-25
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
pnt=pnt->pnt;
}
vor->pnt=neu; // In Liste einfügen
neu->pnt=pnt;
}
}
}

3-26 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
11.4 Direkte Sortierverfahren
Aufgabe 11.4.1 (T1)
a) Welches direkte Sortierverfahren benötigt im Mittel am wenigsten Schlüsselvergleiche?
b) Welches direkte Sortierverfahren benötigt im Mittel am wenigsten Zuweisungen?
c) Welches direkte Sortierverfahren arbeitet für bereits sortierte Daten am schnellsten?
Aufgabe 11.4.2 (P2)
Implementieren Sie die Sortierverfahren direktes Einfügen, direktes binäres Einfügen, direktes
Auswählen, Bubble-Sort und Shaker-Sort. Erzeugen Sie Zufallsfolgen von double-
Zahlen, sortieren Sie diese mit allen implementierten Sortierfunktionen und geben Sie die
Sie jeweiligen die Laufzeiten aus.
Aufgabe 11.4.3 (P3)
Schreiben Sie unter Verwendung des Bubble-Sort ein Programm zum Sortieren einer linearen
Liste am Platz, d.h. ohne wesentlichen zusätzlichen Speicherplatz. Der Bubble-Sort ist
die einzige Sortier-Methode, die dies leistet.
Lösung
//***********************************************************************
// Am-Platz-Sortieren einer linearen List durch Bubble Sort BUBBLE_L.C
//***********************************************************************
#include
#include
struct element { int key; struct element *next; }; // Element
//***********************************************************************
// Ausgabe der linearen Liste
//-----------------------------------------------------------------------
int list(struct element *h) {
struct element *p; // Laufzeiger
printf("\n");
if(h->next==NULL) { printf("Liste ist leer\n"); return(-1); }
p=h->next;
while(p) { // durchlaufe gesamte Liste
printf("%i ",p->key); // Ausgabe eines Elements
p=p->next; // weiter zum nächsten Element
}
return(0);
}
//***********************************************************************
// Anfügen eines Elementes
//-----------------------------------------------------------------------
void add(struct element *h) {
char c[80]="0";
struct element *p;
printf("\nEingabe beenden mit q\n");
while(c[0]!='q') {
printf("Eingabe: ");
scanf("%s",c); // Element einlesen
if(c[0]!='q') {
p=(struct element *) malloc(sizeof(struct element));
p->key=atoi(c); // in Integer umwandeln und am Kopf einfügen

Aufgaben und Lösungen 2-27
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
}
}
}
return;
p->next=h->next;
h->next=p;
//***********************************************************************
// Austauschen zweier aufeinanderfolgender Elemente einer linearen Liste
//-----------------------------------------------------------------------
struct element *swap(struct element *p) {
struct element *t; // temporäres Element
t=p;
p=p->next;
t->next=p->next;
p->next=t;
return(p);
}
//***********************************************************************
// Bubble-Sort für lineare Liste
//-----------------------------------------------------------------------
void sort(struct element *h) {
struct element *p,*q; // Laufzeiger
char go=1; // Flag wird 0, wenn die Liste sortiert ist
while(go) { // solange die Liste noch nicht sortiert ist
go=0;
if(!(q=h->next)) return; // prüfe erstes Element
if(q->key > q->next->key) { // vergleiche mit zweitem Element
go=1;
h->next=swap(q); // und tausche, wenn dieses kleiner ist
}
q=h->next; p=q->next; // betrachte die folgenden Elemente
while(p->next!=NULL) { // durchlaufe die gesamte Liste
if(p->key > p->next->key) { // vergleiche mit nächstem Element
go=1;
q->next=swap(q->next); // und tausche, wenn dieses kleiner ist
}
q=q->next; p=q->next; // gehe zum nächsten Element
}
}
return;
}
//***********************************************************************
// Hauptprogramm
//***********************************************************************
void main() {
struct element *head; // Listenkopf
printf("\n\nBUBBLE SORT IN VERKETTETER LISTE \n");
head=(struct element *) malloc(sizeof(struct element));
head->next=NULL;
for(;;) { // Arbeitsschleife
printf("\n\n1: anhängen 2: sortieren 3: auflisten 4: ende\n");
switch(getch()) { // Kommando lesen
case '1': add(head); break;
case '2': sort(head); break;
case '3': list(head); break;
case '4': case 27: return;
default: break;
}
}
}

3-28 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
11.5 Höhere Sortierverfahren
Aufgabe 11.5.1 (T1)
a) Was bedeutet die Aussage, dass der Quick-Sort entarten kann?
b) Welches Sortierverfahren benötigt die geringste Anzahl von Schlüsselvergleichen?
Aufgabe 11.5.2 (P2)
Modifizieren Sie die im Text angegebene Funktion quicksort(..) so, dass
sie dasselbe Interface erhält, wie die in der C-Bibliothek enthaltene Funktion qsort(..).
Also int quicksort(void *a, int n, size_t w, int (*cmp)())
Vergleichen Sie die Performance Ihres Programm mit der C-Funktion qsort(..).
Aufgabe 11.5.3 (P2)
Schreiben Sie unter Verwendung der C-Funktion qsort() ein Programm zum Sortieren
eines Feldes von Zeigern, die auf Strings deuten. Die Strings sollen dabei in absteigender
Reihenfolge lexikografisch sortiert werden, also c vor b vor a etc.
Aufgabe 11.5.4 (M2)
Ein Test habe ergeben, dass in Abhängigkeit von der Anzahl n der Daten für das Sortieren
von Integer-Arrays mit dem Insertion-Sort auf einer bestimmten Maschine ti=2.8⋅n 2 ⋅10 -5 Sekunden
benötigt werden. Mit dem Quick-Sort benötigt man tq=1.4n⋅ld(n)⋅10 -4 Sekunden. Von
welchem n ab ist der Quick-Sort schneller als der Insertion-Sort?
Lösung
2.8⋅n 2 ⋅10 -5 =1.4n⋅ld(n)⋅10 -4 ist nach n aufzulösen. Es folgt:
0.2⋅n=ld(n) und 2 0.2n =n
Wertetabelle:
n 2 0.2n
10 2 2 =4
20 2 4 =16
22 2 4.4 ≈21.1
23 2 4.6 ≈24.25 ab n=23 ist der Quick-Sort schneller

Aufgaben und Lösungen 2-29
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
11.6 Sortieren externer Dateien
Aufgabe 11.6.1 (T1)
a) Was ist ein nicht-flüchtiger Speicher?
b) Was ist sequentieller und halbsequentieller Speicherzugriff?
c) Was versteht man unter der Zykluszeit im Zusammenhang mit Speicherzugriffen?
d) Was bewirkt eine Defragmentierung?
e) Was ist der Interleave-Faktor?
Aufgabe 11.6.2 (T1)
a) Grenzen Sie die Begriffe direktes und natürliches Mischen ab.
b) Um welchen Faktor könnte das Sortieren durch Mischen schneller werden, wenn man anstelle
von zwei Sequenzen jeweils vier Sequenzen mischt?
c) Nennen Sie den wesentlichen Vorteil des Ein-Phasen-Mischens im Vergleich zum Zwei-
Phasen-Mischen.
Aufgabe 11.6.3 (L1)
Sortieren Sie die Daten a = { 27, 31, 11, 42, 89, 16, 17, 14, 12, 64, 50, 61, 72, 26, 28, 32, 66, 19, 22,
83, 87, 99 } nach dem in Abbildung 11.6.3 vorgeführten Muster per Hand unter Verwendung
des natürlichen Mischens mit zwei Hilfsbändern b und c.
Aufgabe 11.6.4 (P4)
Schreiben Sie eine Funktion zum Sortieren durch Mischen eines Arrays am Platz. Es darf
also kein wesentlicher zusätzlicher, von der Anzahl n der Daten abhängiger Speicherplatz
verwendet werden.

3-30 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
12 Bäume und Graphen
12.1 Binärbäume
Aufgabe 12.1.1 (T1)
a) Was ist ein Nullbaum?
b) Wodurch ist ein innerer Knoten definiert?
c) Was versteht man unter Fädelung?
d) Was versteht man unter Preorder, Inorder und Postorder?
e) Beschreiben Sie das Ordnungskriterium von binären Suchbäumen.
Lösung
Aufgabe 12.1.2 (L2)
Gegeben sei der nebenstehende Binärbaum.
a) Geben Sie die Tiefe des Baumes an.
b) Handelt es sich um einen
erweiterten Binärbaum?
c) Handelt es sich um einen
vollständigen Binärbaum?
d) Geben Sie die Durchsuchungslisten an:
- Hauptreihenfolge (Preorder)
- Nebenreihenfolge (Postorder)
- symmetrischer Reihenfolge (Inorder)
- Ebenenreihenfolge (Levelorder)
Lösung
4
2 6
1 3 5 7 9
8
11
10 12
a) Die Tiefe t eines Baumes ist definiert als die Anzahl der Knoten des längsten Astes. Hier
ist also t=4.
b) Für einen erweiterten Binärbaum gilt, dass jeder Knoten entweder keinen Nachfolger hat
oder zwei hat. Der abgebildete Teilbaum ist also kein erweiterter Binärbaum, da der Knoten
10 nur einen Nachfolger hat.
c) Bei einem vollständigen Binärbaum sind alle Ebenen (Niveaus), evtl. mit Ausnahme der
letzten, vollständig besetzt. Hier sind die Ebenen 0, 1 und 2 vollständig besetzt, die letzte
Ebene 3 ist nicht vollständig besetzt. Es handelt sich also um einen vollständigen Baum.
d) Hauptreihenfolge, Preorder: Wurzel, linker Teilbaum, rechter Teilbaum
8,4,2,1,3,6,5,7,11,10,9,12
Nebenreihenfolge, Postorder: linker TB, rechter TB, Wurzel
1,3,2,5,7,6,4,9,10,12,11,8
Symmetrische Reihenfolge, Inorder: linker TB, Wurzel, rechter TB
1,2,3,4,5,6,7,8,9,10,11,12
Ebenenreihenfolge, Levelorder: Ebenenweise von links nach rechts

Aufgaben und Lösungen 2-31
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
8,4,11,2,6,10,12,1,3,5,7,9
Aufgabe 12.1.3 (P2)
In einem verkettet gespeicherten Binärbaum seien numerische Werte gespeichert. Schreiben
Sie ein Programm zur Durchsuchung dieses Baumes in Hauptreihenfolge, das folgende Informationen
ausgibt: Anzahl der besuchten Knoten, kleinster Inhalt, größter Inhalt, Mittelwert
aller Inhalte.
Programmieren Sie eine rekursive und eine iterative Varianten mit folgender Knoten-Struktur:
struct node { double value; struct node *l; struct node *r; };
Lösung
//******************************************************************
// Ausgabe eines Baumes in Hauptreihenfolge (Preorder)
// Rekursive Variante.
// Rückgabewert: Anzahl der besuchten Knoten.
//******************************************************************
int tree_preorder_rec(struct node *w) {
int cnt=0;
if(w==NULL) return cnt; // Der Baum ist leer
printf("%d ",h->info); // Behandle (drucke) den Knoten
cnt++; // Knotenzähler hochzählen
if(w->l) cnt+=tree_preorder(w->l); // behandle linken Nachfolger
if(w->r) cnt+=tree_preorder(w->r); // behandle rechten Nachfolger
return cnt;
}
//******************************************************************
// Ausgabe eines Baumes in Hauptreihenfolge (Preorder)
// Iterative Variante unter Verwendung eines Stacks.
// MAXDEPTH gibt die maximale Tiefe des Baums an.
// Rückgabewert: Anzahl der besuchten Knoten.
//******************************************************************
int tree_preorder_iter(struct node *w) {
struct node h, *stack[MAXDEPTH+1]={NULL};
int s=0,cnt=0;
if(w==NULL) return cnt; // Der Baum ist leer
h=w;
do {
do {
if(h->r) stack[++t]=h->r; // rechten Nachfoler in Stack
printf("%d ",h->info); // Behandle (drucke) den Knoten
cnt++; // Knotenzähler hochzählen
} while (h=h->l); // gehe zu linkem Nachfolger
} while (h=stack[s--]); // hole Zeichen aus dem Stack
return cnt;
}

3-32 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Aufgabe 12.1.4 (L2)
Ordnen Sie die in der Reihenfolge {6, 9, 3, 7, 13, 21, 10, 8, 11, 14, 5} gegebenen Zahlen als
binären Suchbaum an.
Lösung
6 6 6
Aufgabe 12.1.4 (P4)
8 10 21
Binärer Suchbaum
11 14
6
6
3 9
Schreiben Sie ein Programm zum Verwalten eines binären Suchbaums. Es sollen die Funktionen
Initialisieren des Baums, Eingabe, Suchen und Löschen eines Knotens und Ausgabe
der Knoteninhalte in Haupt-, Neben- und symmetrischer Reihenfolge. Verwenden Sie dabei
die Knotenstruktur
struct node { int info; struct node *l; struct node *r; };
Lösung
9
//************************************************************************
// Programm zur Verwaltung eines binären Suchbaumes
// mit Eingabe, Suchen, Löschen von Knoten und Ausgabe in
// Hauptreihenfolge, symmetrischer Reihenfolge und Nebenreihenfolge.
//************************************************************************
#include
#include
#include
#include
#include
#include
3 9
3
9
6 6 6
3 9
6
7 13
3 9
13
6
7
3 9
5 7 13
3 9
13
6
7
3 9
7 13
7
3 9
13
8 10 21
6
7
3 9
7 13
8 10 21
11 11 14

Aufgaben und Lösungen 2-33
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
#define CR 13
#define ESC 27
#define BLNK 32
#define DIM 80
#define MAXDEPTH 10
struct node { int key; // Schlüssel (Informationsteil)
struct node *l,*r; // Zeiger auf die Nachfolger
}; // Baumstruktur
int getkey(); // Funktionsprototypen
void prelist(struct node *p);
void inlist(struct node *p);
void postlist(struct node *p);
int prelist_iter(struct node *p);
struct node *node_init(int key);
int tree_search(struct node *p, int key);
int tree_del(struct node *p, int key);
int tree_in(struct node *root, int key);
void tree_free(struct node *p);
//------------------------------------------------------------------------
// Hauptprogramm
//------------------------------------------------------------------------
int main() {
printf("\nEingabe und Ausgabe von binaeren Suchbaeumen");
printf("\n============================================\n");
int c=0, i, e, key;
char buffer[DIM+1];
struct node *root=NULL, *p;
while(c!=ESC) { // Arbeitsschleife
printf("\n\nNeuer Baum (n):"); // Menü
printf("\nKnoten eingeben (e):");
printf("\nAusgabe (a):");
printf("\nSuchen (s):");
printf("\nLoeschen (l):");
printf("\nBeenden : ");
c=toupper(getkey()); // Kommando lesen
if(c==ESC) return 0; // Programm beenden
////////////////////////////////////////// Eingabe
if(c=='N' || c=='E') {
if(c=='E') e=1; else e=0;
i=1;
if(e) { // Eingabe eines Knotens
if(root==NULL) {
printf("\n\nDer Baum ist nicht initialisiert!");
i=0;
}
else
printf("\n\nEingabe eines Schluessels (Integer-Zahl):");
}
else { // Anlegen eines neuen Baums
tree_free(root); // alten Baum löschen
root=node_init(0); // Baum initialisieren
if(root==NULL) { // nicht genug Speicher
printf("\n\nNicht genug Speicher!");
i=0;
}
else {
printf("\n\nEs wird ein neuer Baum aufgebaut.\nEingabe ");
printf("von Schluesseln (Integer-Zahlen), beenden mit :");
}
}

3-34 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
if(i) while(c!=ESC) { // Schleife für Eingabe
printf("\n> "); // neues Element
i=0;
while((c=getkey())!=CR) { // Zeichen lesen
if(i==DIM) break; // Eingabe zu lang
if(c>=BLNK) { // druckbares Zeichen
putch(c); // .. anzeigen
buffer[i++]=c; // .. in Puffer kopieren
}
else if(c==CR || c==ESC) break; // Eingabe beenden
}
if(i>0) {
buffer[i]=0; // Puffer abschließen
key=atoi(buffer); // Puffer in Integer konvert.
i=tree_in(root,key); // Element einfügen
if(i==0) { // nicht genug Speicher
printf("\n\nNicht genug Speicher!");
break;
}
}
if(e) c=ESC;
}
}
////////////////////////////////////////// Ausgabe des Baums
else if(c=='A') {
if(root==NULL) printf("\n\nDer Baum ist nicht initialisiert!");
else if(root->l==NULL) printf("\n\nDer Baum ist leer!");
else {
printf("\n\nAusgabe:\n");
printf("\nHauptreihenfolge: ");
prelist_iter(root->l);
printf("\nSym. Reihenfolge: ");
inlist(root->l);
printf("\nNebenreihenfolge: ");
postlist(root->l);
}
}
////////////////////////////////////////// Suchen eines Schlüssels
else if(c=='S') {
if(root==NULL) printf("\n\nDer Baum ist nicht initialisiert!");
else if(root->l==NULL) printf("\n\nDer Baum ist leer!");
else {
printf("\n\nBitte zu suchenden Schluessel eingeben: ");
scanf("%d",&key);
i=tree_search(root,key);
if(i==-1) printf("\nSchluessel %d nicht gefunden.",key);
else printf("\nSchluessel %d nach %d Schritten gefunden.",key,i);
}
}
////////////////////////////////////////// Löschen eines Schlüssels
else if(c=='L') {
if(root==NULL) printf("\n\nDer Baum ist nicht initialisiert!");
else if(root->l==NULL) printf("\n\nDer Baum ist leer!");
else {
printf("\n\nBitte zu loeschenden Schluessel eingeben: ");
scanf("%d",&key);
i=tree_del(root,key);
if(i==-1) printf("\nSchluessel %d nicht gefunden.",key);
else printf("\nSchluessel %d nach %d Schritten geloescht.",key,i);
}
}
else printf("\n\nFalsche Eingabe!"); // Falsche Eingabe
c=0;

Aufgaben und Lösungen 2-35
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
}
}
tree_free(root); // Speicher freigeben
return 0;
//------------------------------------------------------------------------
// Ein Zeichen von der Tastatur lesen.
// Hinweis: Manche Sonderzeichen bestehen aus zwei Byte, wobei das erste
// Byte den Wert 0 oder 224 hat.
// Rückgabe-Wert:
// 8-Bit ASCII-Code des Zeichens oder der negative Wert des Codes,
// wenn es sich um ein Sonderzeichen aus zwei Byte handelt.
//------------------------------------------------------------------------
int getkey() {
int i;
i=getch(); // erstes Byte
if(kbhit()) return -getch(); // noch ein Byte?
return i;
}
//------------------------------------------------------------------------
// Ausgabe eines Baumes in Hauptreihenfolge (Preorder)
//------------------------------------------------------------------------
void prelist(struct node *p) {
printf("%d ",p->key); // behandle Wurzel (drucke key)
if(p->l) prelist(p->l); // behandle linken Nachfolger
if(p->r) prelist(p->r); // behandle rechten Nachfolger
}
//------------------------------------------------------------------------
// Ausgabe eines Baumes in symmetrischer Reihenfolge (Inorder)
//------------------------------------------------------------------------
void inlist(struct node *p) {
if(p->l) inlist(p->l); // behandle linken Nachfolger
printf("%d ",p->key); // behandle Wurzel (drucke key)
if(p->r) inlist(p->r); // behandle rechten Nachfolger
}
//------------------------------------------------------------------------
// Ausgabe eines Baumes in Nebenreihenfolge (Postorder)
//------------------------------------------------------------------------
void postlist(struct node *p) {
if(p->l) postlist(p->l); // behandle linken Nachfolger
if(p->r) postlist(p->r); // behandle rechten Nachfolger
printf("%d ",p->key); // behandle Wurzel (drucke key)
}
//------------------------------------------------------------------------
// Ausgabe eines Baumes in Hauptreihenfolge - iterative Lösung
// Rückgabewert: 0 für normale Ausführung
// -1 bei Stack-Überlauf
//------------------------------------------------------------------------
int prelist_iter(struct node *p) {
struct node *s[MAXDEPTH]={NULL}; // Stack
int t=0; // Stack-Pointer
if(p==NULL) return 0; // der Baum ist leer
while(p) { // Arbeitsschleife
while(p) { // gehe nach links bis zu einem Blatt
if(p->r) { // gibt es einen rechten Nachfolger?
if(++t==MAXDEPTH) return -1; // Stack-Überlauf
s[t]=p->r; // rechten Nachfolger in Stack
}
printf("%d ",p->key); // bearbeite Wurzel (drucke key)

3-36 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
}
p=p->l; // weiter zum linken Nachfolger
}
p=s[t--]; // Knoten aus Stack holen
}
return 0;
//------------------------------------------------------------------------
// Einfügen eines Elementes in einen Binärbaum
// Rückgabewert: 0 bei normaler Ausführung
// -1 wenn nicht genug Speicher
//------------------------------------------------------------------------
int tree_in(struct node *root, int key) {
int dir=0;
struct node *p, *v=root, *k=root->l;
p=node_init(key); // neuen Knoten erzeugen
if(p==NULL) return -1; // nicht genug Speicher
while(k) { // .. Einfügestelle suchen
v=k; // Vorgänger
if(keykey) {
k=k->l; // Verzweige nach links
dir=0; // Verzweigungsrichtung merken
}
else { // Verzweige nach rechts
k=k->r;
dir=1; // Verzweigungsrichtung merken
}
}
if(dir) v->r=p; // Einfügen von p als rechten ..
else v->l=p; // .. oder linken Nachfolger
}
//------------------------------------------------------------------------
// Suchen eines Schlüssels key in einem Binärbaum
// Rückgabewert: Anzahl der Schritte
// -1 wenn nicht gefunden
//------------------------------------------------------------------------
int tree_search(struct node *root, int key) {
int cnt=1;
struct node *k=root->l; // Start mit der Wurzel
while(k) { // Schlüssel key suchen
if(k->key==key) return cnt; // Schlüssel gefunden
else if(key < k->key) k=k->l; // gehe zum linken Nachfolger
else k=k->r; // gehe zum rechten Nachfolger
cnt++; // Schrittzähler inkrementieren
}
return -1; // nicht gefunden
}
//------------------------------------------------------------------------
// Löschen eines Schlüssels key in einem Binärbaum
// Rückgabewert: Anzahl der Schritte
// -1 wenn nicht gefunden
//------------------------------------------------------------------------
int tree_del(struct node *root, int key) {
int cnt=1, dir=0;
struct node *v=root, *k=root->l; // Start mit der Wurzel
struct node *s, *vs; // Symm. Vorgänger s und dessen Vorg.
while(k) { // Schlüssel key suchen
if(k->key==key) break; // Schlüssel gefunden
v=k; // Vorgänger merken
if(key < k->key) { // Schlüssel vergleichen
k=k->l; // gehe zum linken Nachfolger

Aufgaben und Lösungen 2-37
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
}
dir=0; // Verzweigungsrichtung merken
}
else {
k=k->r; // gehe zum rechten Nachfolger
dir=1; // Verzweigungsrichtung merken
}
cnt++; // Schrittzähler inkrementieren
}
if(k==NULL) return -1; // nicht gefunden
///////////////////////////////////// Blatt löschen
if(k->l==NULL && k->r==NULL) {
if(dir) v->r=NULL; // Blatt ist rechter Nachfolger
else v->l=NULL; // Blatt ist linker Nachfolger
}
///////////////////////////////////// Knoten mit einem Nachf. löschen
else if(k->l==NULL && k->r!=NULL) {// k hat nur rechten Nachfolger
if(dir) v->r=k->r; // k ist rechter Nachfolger von v
else v->l=k->r; // k ist linker Nachfolger von v
}
else if(k->l!=NULL && k->r==NULL) {// k hat nur linken Nachfolger
if(dir) v->r=k->l; // k ist rechter Nachfolger von v
else v->l=k->l; // k ist linker Nachfolger von v
}
///////////////////////////////////// inneren Knoten löschen
else if(k->l!=NULL && k->r!=NULL) {
vs=k; // Symmetrischen Vorgänger s suchen
s=k->l; // gehe einen Schritt nach links
while(s->r) { // gehe nach rechts bis zum Ende
vs=s; // Vorgänger vs des Sym. Vorgängers
s=s->r; // Symmetrischer Vorgänger s
}
if(vs!=k) { // Linken Nachfolger von s an Vorg. ..
vs->r=s->l; // .. des Sym. Nachf. hängen
s->l=k->l; // s an die Position von k bringen
}
s->r=k->r; // s an die Position von k bringen
if(dir) v->r=s; // k ist rechter Nachfolger von v
else v->l=s; // k ist linker Nachfolger von v
}
free(k); // Knoten k löschen
return cnt;
//------------------------------------------------------------------------
// Knoten eines Binärbaums initialisieren.
// Rückgabewert:
// Zeiger auf den Knoten oder NULL, wenn nicht genug Speicherplatz.
//------------------------------------------------------------------------
struct node *node_init(int key) {
struct node *p;
p=(struct node *)malloc(sizeof(struct node));
if(p==NULL) return NULL; // nicht genug Speicher
p->key=key; // Schlüssel zuweisen
p->l=p->r=NULL; // keine Nachfolger
return p;
}
//------------------------------------------------------------------------
// Der durch den Baum belegte Speicherplatz wird freigegeben.
// Durchlaufen in Nebenreihenfolge, d.h. es werden immer Blätter gelöscht.
//------------------------------------------------------------------------
void tree_free(struct node *p) {
if(p==NULL) return; // der Baum ist nicht initialisiert

3-38 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
}
if(p->l) tree_free(p->l); // rekursiv zum linken Nachfolger
if(p->r) tree_free(p->r); // rekursiv zum rechten Nachfolger
free(p); // Knoten löschen
Aufgabe 12.1.6 (L2)
Ein erweiterter Binärbaum ist dadurch gekennzeichnet, dass jeder Knoten entweder keinen
oder zwei Nachfolger hat. Zeigen Sie: In einem erweiterten Binärbaum gilt ne=ni+1, wobei ne
die Anzahl der Blätter ist und ni die Anzahl der der inneren Knoten.
Lösung
Die Skizze zeigt die drei kleinsten erweiterten Binärbäume, wobei die inneren Knoten als
schwarze Punkte und die externen Knoten (Blätter) als Quadrate gezeichnet sind. Für diese
gilt offenbar die Behauptung ne=ni+1. Ein erweiterter Binärbaum kann nur wachsen, indem
ein Blatt durch einen aus Wurzel und zwei Blättern bestehenden Baum ersetzt wird. Es
kommen also immer genau ein innerer Knoten und genau ein Blatt hinzu, so dass die Behauptung
weiterhin erfüllt bleibt.
Aufgabe 12.1.7 (P2)
Schreiben Sie eine C-Funktion, die von einem verkettet gespeicherten Binärbaum die Anzahl
der Knoten mit zwei Nachfolgern angibt. Die Knoten-Struktur sei:
struct node { int info; struct node *l; struct node *r; };
Lösung
int nodes(struct node *w) {
if(!w) return 0;
if(w->l!=NULL && w->r!=NULL) return nodes(w->l)+nodes(w->r)+1;
else if(w->l!=NULL && w->r==NULL) return nodes(w->l);
else if(w->l==NULL && w->r!=NULL) return nodes(w->r);
}
Aufgabe 12.1.8 (P3)
Schreiben Sie ein möglichst effizientes Programm, mit dem festgestellt werden kann, ob zwei
lineare Listen mit jeweils n Elementen vom Typ Integer dieselben Elemente enthalten. Dabei
ist nicht vorausgesetzt, dass die Elemente in den beiden Listen in derselben Reihenfolge
angeordnet sind. Verwenden Sie dazu einen binären Suchbaum. Bestimmen Sie die im Mittel
zu erwartende Komplexität hinsichtlich der Anzahl der Vergleiche.
Lösung
Aufgabe 12.1.9 (P2)
Schreiben Sie unter Verwendung eines binären Suchbaums ein Programm, das alle doppelt
vorkommenden Zahlen aus einem Array von Zufallszahlen löscht. Bestimmen Sie die Komplexität
des Algorithmus hinsichtlich der Anzahl der Vergleiche.
Lösung

Aufgaben und Lösungen 2-39
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
/**********************************************************************/
/* Elimination von doppelt vorkommenden Zahlen in DOUBLE.C */
/* einem Array unter Verwendung eines binären Suchbaums. */
/**********************************************************************/
#include
#define DIM 100
struct node { int key; /* Info-Teil */
struct node *l,*r; /* Zeiger auf die Nachfolger */
}; /* Baumstruktur */
/**********************************************************************/
/* Sortiertes Kopieren eines Baumes auf ein Array (symm. Reihenfolge).*/
/*--------------------------------------------------------------------*/
void tree_copy(struct node *p, int a[]) {
static n=0; /* Index für Array */
if(p->l) tree_copy(p->l,a); /* Bearbeite linken Teilbaum */
a[n++]=p->key; /* Kopiere die Wurzel nach a */
if(p->r) tree_copy(p->r,a); /* Bearbeite rechten Teilbaum */
return;
}
/**********************************************************************/
/* Aufbau eines binären Suchaums aus einem Array a mit n Elementen. */
/* Bereits vorhandene Elemente werden nicht doppelt eingetragen. */
/* Rückgabewert ist die Anzahl der Elemente. */
/*--------------------------------------------------------------------*/
int tree_build(struct node *p, int a[], int n) {
int i, r, m=0;
struct knoten *v, *k;
p->key=a[0]; /* Wurzel einfügen */
for(i=1; ikey) break; /* Knoten schon vorhanden */
v=k;
if(a[i]>k->key) { k=k->r; r=1; }
else { k=k->l; r=0; }
}
if(k==NULL) { /* Einfügen */
k=(struct knoten *)malloc(sizeof(struct knoten)); /*neuer Knoten*/
k->key=a[i];
k->l=k->r=NULL;
if(r) v->r=k; /* als rechten Nachfolger einfügen */
else v->l=k; /* als linken Nachfolger einfügen */
m++;
}
}
return(m);
}
/**********************************************************************/
/* Hauptprogramm */
/**********************************************************************/
void main() {
int i,n;
int a[DIM];
struct node *head;
srand(1);
for(i=0; i

3-40 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
}
for(i=0; il=head->r=NULL;
n=tree_build(head,a,DIM); /* Baum ohne Doppeleinträge aufbauen */
tree_copy(head,a); /* Baum auf Array zurückkopieren */
printf("\nErgebnis:\n");
for(i=0; i

Aufgaben und Lösungen 2-41
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Bei der Ordnung als Min-Heap steht das kleinste Element in der Wurzel, alle weiteren Elemente
sind größer oder gleich dem jeweiligen Vorgänger. Man erhält also bei schrittweisem Einfügen
der Elemente:
4 4 2
2
2
2
2
6 6 4 6 4 5 4 5 2 5 2
7
7 6
7 6 4 7 6 4 14
2
1
1
5 2
2 2
2 2
7 6 4 14 5 6 4 14 5 3 4 14
12
12 7
12 7 6
1
2 2
1
2 2
1
2 2
5 3 4 14 5 3 4 14 5 3 4 14
12 7 6 13
1
12 7 6 13 8
12 7 6 13 8 10
2 2
5 3 4 14
12 7 6 13 8 10 16 Min-Heap
Aufgabe 12.1.12 (L2)
Geben Sie ein Beispiel für einen Max-Heap mit 5 Knoten an, der gleichzeitig ein binärer
Suchbaum ist. Dabei dürfen auch identische Schlüssel zugelassen werden.
Lösung
Bei einem binären Suchbaum gilt für den Schlüssel eines jeden Knotens, dass der Schlüssel
des linken Nachfolgers kleiner (oder gleich) und der Schlüssel des rechten Nachfolgers größer
(oder gleich) ist. Bei einem Max-Heap gilt eine schwächere Ordnungsbeziehung. Es wird
nur gefordert, dass der Schlüssel eines jeden Knotens mit
Ausnahme der Wurzel kleiner (oder gleich) dem Schlüssel
des Vorgängers ist. Lässt man identische Schlüssel zu,
so kann man Heaps konstruieren, die gleichzeitig binäre Such-
bäume sind, wie der nebenstehende Baum mit fünf Knoten zeigt.
3
2 3
1 2

3-42 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
12.2 Vielwegbäume
Aufgabe 12.2.1 (T2)
a) Was ist bei Vielwegbäumen ein Bruder?
b) Wodurch unterscheidet sich ein BB-Baum von einem (2,4)-Baum?
c) Was ist ein (a,b)-Baum?
d) Was ist ein B*-Baum?
e) Was ist eine Hecke?
Lösung
b) Sowohl ein BB-Baum als auch ein (2,4)-Baum ist ein B-Baum. Die Bezeichnung BB-
Baum steht für (1,2)-Baum, jede Seite umfasst daher mindestens ein Element und höchstens
zwei. Ein BB-Baum mit n Elementen hat ca. die doppelte Tiefe wie ein (2,4)-Baum
mit derselben Anzahl von Elementen. Ein BB-Baum ist weniger für die Arbeit auf externen
Speichern geeignet, sondern eher dann, wenn er komplett im Hauptspeicher gehalten
werden kann.
Aufgabe 12.2.2 (L2)
Ordnen Sie die in der Reihenfolge {6, 9, 3, 7, 13, 21, 10, 8, 11, 14, 5} gegebenen Zahlen als
(2,4)-Baum.
Lösung
6 6 9 3 6 9 3 6 7 9
3 6
3 6
3 6
3 6
3 5 6
7
9 13
7
9 10 13 21
7 10
3 6
8 9 11 13 21
7 10
3 6
8 9 11 13 14 21
7 10
8 9 11 13 14 21
7 10
8 9
7
(2,4)-Baum
9 13 21
13 21

Aufgaben und Lösungen 2-43
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Aufgabe 12.2.3 (L3)
In den unten abgebildeten (2,4)-Baum soll das Element mit Schlüssel 3 eingefügt werden.
Zeichnen Sie den resultierenden Baum. Löschen Sie anschließend Das Element mit dem
Schlüssel 6 und zeichnen Sie den resultierenden Baum erneut.
2 4 6 8
Lösung
10 20 30 40
12 14 16 18 22 24 26 28 32 34 36 32 42 44 46 48
20
4 10 30 40
2 3 12 14 16 18 22 24 26 28 42 44 46 48
Aufgabe 12.2.4 (L3)
6 8 32 34 36 38
Wie viele Elemente können in einem (2,4)-Baum der Tiefe 3 maximal und minimal enthalten
sein? Die Wurzel (Niveau 0) hat die Tiefe 1.
Lösung
Die Maximale Anzahl ergibt sich, wenn alle Seiten der drei Niveaus mit jeweils 4 Elementen
voll besetzt sind. Da dann jede Seite fünf Nachfolgeseiten hat, folgt:
Niveau 0: n0=4, Niveau 1: n1=5·4, Niveau 2: n2=5·5·4, Summe: n=124
Die minimale Anzahl von Elementen in einem (2,4)-Baum der Tiefe 3 ergibt sich, wenn die
Wurzel (Niveau 0) mit nur einem Element besetzt ist. Daraus folgt dann, dass Niveau 1 aus
nur zwei Seiten besteht. Diese können dann minimal mit je zwei Elementen besetzt sein, so
dass jede Seite aus Niveau 1 auf je drei Seiten in Niveau 2 verweiset. Die Seiten in Niveau 2
können wiederum minimal mit zwei Elementen besetzt sein. Insgesamt ergibt sich:
Niveau 0: n0=1, Niveau 1: n1=2·2, Niveau 2: n2=2·3·3, Summe: n=17
Aufgabe 12.2.5 (P4)

3-44 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Schreiben Sie ein Programm zum Verwalten eines (2,4)-Baums. Es sollen die Funktionen
Initialisieren des Baums, Eingabe, Suchen und Löschen von Einträgen und Ausgabe der
Inhalte realisiert werden.

Aufgaben und Lösungen 2-45
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
12.3 Graphen
Aufgabe 12.3.1 (T1)
a) Wann ist ein Graph schlicht?
b) Was ist ein Euler’scher Kreis?
c) Was ist ein Hamilton’scher Kreis?
d) Was ist der Grad eines Knotens?
e) Was ist ein Wald?
f) Was ist ein Kuratowski-Graph?
Lösung
Aufgabe 12.3.2 (L3)
Gegeben sei der nebenstehende Graph.
a) Geben Sie die Knotenliste und die Kantenliste an.
b) Geben Sie den Forward Star an.
c) Geben Sie die Adjazenzmatrix und die
Erreichbarkeitsmatrix an.
d) Listen Sie, beginnend mit Knoten E, die Knoten in der
Reihenfolge gemäß Tiefensuche und Breitensuche auf.
e) Zeichnen Sie den Graphen so um, dass die Knoten von links
nach rechts in einer topologischen Sortierung angeordnet sind.
f) Geben Sie den minimalen Spannbaum an.
g) Welche der folgenden Eigenschaften treffen auf den Graphen zu: eben, zusammenhängend,
stark zusammenhängend, kreisfrei, schlicht, gerichtet, vollständig, bewertet?
Lösung
Knotenliste Kantenliste
A H
B A, D, F
C F
D -
E B, D
F H
G D
H G
Adjazenzmatrix
v
o
n
nach
A B C D E F G H
A 0 0 0 0 0 0 0 1
B 1 0 0 1 0 1 0 0
C 0 0 0 0 0 1 0 0
D 0 0 0 0 0 0 0 0
E 0 1 0 1 0 0 0 0
F 0 0 0 0 0 0 0 1
G 0 0 0 1 0 0 0 0
H 0 0 0 0 0 0 1 0
Tiefensuche: EBAHGFD
A
E
3
2
B
1
4
F
5
1
C
3
3
H
1
D
G
2

3-46 Aufgaben und Lösungen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Breitensuche: EBDAFHG
Topologische Sortierung
Minimal spannender Baum:
Eigenschaften: Ja Nein
eben
zusammenhängend
stark zusammenhängend
kreisfrei
schlicht
gerichtet
vollständig
bewertet
Aufgabe
C E B A F H G D
A
E
3
2
B
1
4
5
F
a) Welche Bedingung muss erfüllt sein, damit ein vollständiger Graph genau n(n-1)/2 Kanten
hat?
b) Beweisen Sie durch vollständige Induktion, dass ein vollständiger Graph mindestens
n(n-1)/2 Kanten hat.
c) Zeigen Sie: Jeder kreisfreie Graph mit n Knoten enthält höchstens n-1 Kanten.
d) Auf welche Eigenschaft muss man die Adjazenzmatrix eines Graphen testen, um zu
entscheiden, ob er schlingenfrei ist?
e) Wie groß ist die minimale und wie groß ist die maximale Anzahl von Kanten eines schlichten,
zusammenhängenden Graphen mit n Knoten?
f) Wie viele Knoten hat ein ungerichteter, schlichter, vollständiger Graph mit 465 Kanten?
g) Wie viele Kanten hat ein nicht-ebener, zusammenhängender Graph mit n Knoten
mindestens?
Lösung
Aufgabe 12.3.4 (P2)
Schreiben Sie eine C-Funktion zur topologischen Sortierung eines Digraphen mit n Knoten.
Gegeben seien die Kantenliste als Array klist und die global deklarierte Adjazenzmatrix
a[n][n]. Die Funktion soll als Ergebnis die Indizes der Knoten bezüglich klist in der sortierten
Reihenfolge in ein Integer-Array tlist eintragen.
Lösung
#define DIM 20
int a[DIM][DIM]; // Global deklarierte Adjazenzmatrix
1
C
3
3
H
1
D
G
2

Aufgaben und Lösungen 2-47
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
int tsort(int tlist[]; int klist[]; int n) {
int i, j, k=0, grad[DIM];
if(n=DIM) return(-1);
for(i=0; i