Ulrich Kaiser, Christoph Kecher...Ulrich Kaiser, Christoph Kecher C/C++ 839.book Seite 1 Dienstag,...

Ulrich Kaiser, Christoph Kecher

C/C++

839.book Seite 1 Dienstag, 9. September 2008 11:49 11

Auf einen Blick

1 Einige Grundbegriffe ..................................................................... 21

2 Einführung in die Programmierung ............................................... 35

3 Ausgewählte Sprachelemente von C ............................................. 43

4 Arithmetik ..................................................................................... 73

5 Aussagenlogik ............................................................................... 97

6 Elementare Datentypen und ihre Darstellung ............................... 129

7 Modularisierung ............................................................................ 181

8 Zeiger und Adressen ...................................................................... 253

9 C-Referenz (Teil 1) ......................................................................... 271

10 Kombinatorik ................................................................................ 315

11 Leistungsanalyse und -messung von Algorithmen ........................ 349

12 Sortierverfahren ............................................................................. 395

13 Datenstrukturen ............................................................................ 441

14 C-Referenz (Teil 2) ......................................................................... 497

15 Ausgewählte Datenstrukturen ...................................................... 519

16 Elemente der Graphentheorie ....................................................... 613

17 Projekt 2D-Grafikprogrammierung ............................................... 701

18 C++-Referenz (Teil 1) ..................................................................... 703

19 Objektorientierte Programmierung ............................................... 743

20 Klassen in C++ ............................................................................... 759

21 Vererbung in C++ ........................................................................... 823

22 C++-Referenz (Teil 2) ..................................................................... 893

23 Die C++-Standard-Library ............................................................. 983

24 Projekt: 3D-Grafikprogrammierung .............................................. 1077

Anhang ........................................................................................... 1079

Lösungen ....................................................................................... 1083


5

Inhalt

Vorwort ................................................................................................. 17Danksagung ........................................................................................... 18Vorwort zur zweiten Auflage .................................................................. 19Vorwort zur vierten Auflage ................................................................... 20

1 Einige Grundbegriffe ................................................................ 21

1.1 Algorithmus ................................................................................. 231.2 Datenstruktur .............................................................................. 271.3 Programm .................................................................................... 291.4 Aufgaben ..................................................................................... 32

2 Einführung in die Programmierung .......................................... 35

2.1 Die Programmierumgebung ......................................................... 402.1.1 Der Editor ..................................................................... 402.1.2 Der Compiler ................................................................ 412.1.3 Der Linker ..................................................................... 422.1.4 Der Debugger ............................................................... 42

3 Ausgewählte Sprachelemente von C ....................................... 43

3.1 Programmrahmen ........................................................................ 433.2 Zahlen ......................................................................................... 443.3 Variablen ..................................................................................... 443.4 Operationen ................................................................................ 46

3.4.1 Zuweisungsoperationen ................................................ 463.4.2 Rechenoperationen ....................................................... 473.4.3 Vergleichsoperationen .................................................. 49

3.5 Kommentare ................................................................................ 493.6 Elementare Ein-/Ausgabe ............................................................. 50

3.6.1 Bildschirmausgabe ........................................................ 503.6.2 Tastatureingabe ............................................................ 52

3.7 Kontrollfluss ................................................................................ 523.7.1 Bedingte Befehlsausführung .......................................... 533.7.2 Wiederholte Befehlsausführung ..................................... 543.7.3 Verschachtelung von Kontrollstrukturen ........................ 60

3.8 Beispiele ...................................................................................... 613.8.1 Das erste C-Programm .................................................. 61


Inhalt

6

3.8.2 Das zweite C-Programm ................................................ 623.8.3 Das dritte C-Programm ................................................. 66

3.9 Aufgaben ..................................................................................... 69

4 Arithmetik ................................................................................ 73

4.1 Folgen ......................................................................................... 734.2 Summen ...................................................................................... 804.3 Produkte ..................................................................................... 874.4 Aufgaben ..................................................................................... 89

5 Aussagenlogik .......................................................................... 97

5.1 Aussagen ..................................................................................... 975.2 Logische Operatoren ................................................................... 985.3 Darstellung boolescher Funktionen .............................................. 1065.4 Vereinfachung boolescher Ausdrücke ........................................... 1115.5 Logische Operatoren in C ............................................................ 1195.6 Programmierbeispiele .................................................................. 120

5.6.1 Kugelspiel ..................................................................... 1205.6.2 Schaltung ...................................................................... 121

5.7 Aufgaben ..................................................................................... 124

6 Elementare Datentypen und ihre Darstellung ......................... 129

6.1 Zahlendarstellungen .................................................................... 1296.1.1 Dezimaldarstellung ....................................................... 1316.1.2 Dualdarstellung ............................................................. 1316.1.3 Oktaldarstellung ........................................................... 1336.1.4 Hexadezimaldarstellung ................................................ 134

6.2 Bits und Bytes .............................................................................. 1366.3 Skalare Datentypen in C ............................................................... 140

6.3.1 Ganze Zahlen ................................................................ 1416.3.2 Aufzählungstypen ......................................................... 1426.3.3 Gleitkommazahlen ........................................................ 1426.3.4 Buchstaben ................................................................... 143

6.4 Bit-Operationen ........................................................................... 1476.5 Programmierbeispiele mit Zeichen, Zahlen und

Bit-Operationen ........................................................................... 1506.5.1 Zeichensatz ................................................................... 1506.5.2 Bit-Editor ...................................................................... 152


Inhalt

7

6.6 Arrays und Zeichenketten ............................................................ 1566.6.1 Arrays ........................................................................... 1566.6.2 Zeichenketten ............................................................... 161

6.7 Programmierbeispiele mit Arrays und Strings ............................... 1676.7.1 Buchstaben zählen ........................................................ 1676.7.2 Matrixdruck .................................................................. 170

6.8 Aufgaben ..................................................................................... 173

7 Modularisierung ....................................................................... 181

7.1 Funktionen und Unterprogramme ................................................ 1817.2 Rekursion .................................................................................... 1887.3 Der Stack ..................................................................................... 1967.4 Globale, lokale und statische Variablen ........................................ 1997.5 Die C-Runtime-Library ................................................................. 201

7.5.1 Mathematische Funktionen ........................................... 2017.5.2 Konvertierungs- und Klassifizierungsroutinen ................ 2047.5.3 Stringbearbeitung ......................................................... 2067.5.4 Terminal I/O ................................................................. 2087.5.5 Dateioperationen .......................................................... 2137.5.6 Suchen und Sortieren .................................................... 2167.5.7 Variable Anzahl von Argumenten .................................. 2167.5.8 Ausnahme- und Fehlerbehandlung ................................ 2197.5.9 Assertions und Programmabbruch ................................. 2237.5.10 Freispeicherverwaltung und Speicherfunktionen ............ 2257.5.11 Zeit- und Datum-Funktionen ........................................ 2257.5.12 Prozess-Steuerung ......................................................... 226

7.6 Beispiele ...................................................................................... 2267.6.1 Das Damenproblem ...................................................... 2267.6.2 Labyrinth ...................................................................... 234

7.7 Aufgaben ..................................................................................... 240

8 Zeiger und Adressen ................................................................. 253

8.1 Zeigerarithmetik .......................................................................... 2578.2 Arrays und Zeiger ......................................................................... 2598.3 Funktionszeiger ........................................................................... 2628.4 Komplexe Variablendeklarationen ................................................ 2668.5 Aufgaben ..................................................................................... 268


Inhalt

8

9 C-Referenz (Teil 1) .................................................................... 271

9.1 Reservierte Wörter ...................................................................... 2719.2 Identifier ..................................................................................... 2719.3 Numerische Werte ....................................................................... 2729.4 Werte für Zeichen und Zeichenketten .......................................... 2739.5 Skalare Datentypen ...................................................................... 2749.6 Variablen ..................................................................................... 2749.7 Arrays .......................................................................................... 2799.8 Operatoren .................................................................................. 279

9.8.1 Arithmetische Operatoren ............................................. 2849.8.2 Vergleichsoperatoren .................................................... 2859.8.3 Logische Operatoren ..................................................... 2859.8.4 Bit-Operatoren ............................................................. 2869.8.5 Zugriffsoperatoren ......................................................... 2869.8.6 Auswertungsoperatoren ................................................ 2879.8.7 Datentyp-Operatoren ................................................... 2889.8.8 Ausdrücke und Zuweisungsoperatoren .......................... 289

9.9 Funktionen .................................................................................. 2939.10 Kontrollstrukturen ....................................................................... 295

9.10.1 Alternativen .................................................................. 2959.10.2 Sprungleisten ................................................................ 2969.10.3 Schleifen ....................................................................... 2989.10.4 Sprunganweisungen ...................................................... 300

9.11 Der Preprozessor ......................................................................... 3029.11.1 Includes ........................................................................ 3029.11.2 Symbolische Konstanten ............................................... 3039.11.3 Makros ......................................................................... 3059.11.4 Bedingte Compilierung .................................................. 306

9.12 Der Aufbau von Programmdateien ............................................... 3089.12.1 Header-Dateien ............................................................ 3099.12.2 Quellcode-Dateien ........................................................ 310

9.13 Einige Coding-Standards .............................................................. 311

10 Kombinatorik ........................................................................... 315

10.1 Kombinatorische Grundaufgaben ................................................. 31610.1.1 Permutationen mit Wiederholungen ............................. 31610.1.2 Permutationen ohne Wiederholungen ........................... 31710.1.3 Kombinationen ohne Wiederholungen .......................... 318


Inhalt

9

10.1.4 Kombinationen mit Wiederholungen ............................ 32010.1.5 Zusammenfassung ......................................................... 322

10.2 Kombinatorische Algorithmen ..................................................... 32410.2.1 Permutationen mit Wiederholungen ............................. 32510.2.2 Kombinationen mit Wiederholungen ............................ 32810.2.3 Kombinationen ohne Wiederholungen .......................... 33010.2.4 Permutationen ohne Wiederholungen ........................... 332

10.3 Beispiele ...................................................................................... 33510.3.1 Juwelenraub .................................................................. 33510.3.2 Geldautomat ................................................................. 340

10.4 Aufgaben ..................................................................................... 345

11 Leistungsanalyse und -messung von Algorithmen .................. 349

11.1 Leistungsanalyse .......................................................................... 35211.2 Leistungsmessung ........................................................................ 364

11.2.1 Überdeckungsanalyse .................................................... 36611.2.2 Performance-Analyse .................................................... 367

11.3 Mathematische Grundfunktionen ................................................. 36911.3.1 Floor und Ceiling .......................................................... 36911.3.2 Potenzfunktionen .......................................................... 37111.3.3 Exponentialfunktionen .................................................. 37211.3.4 Logarithmen ................................................................. 373

11.4 Laufzeitklassen ............................................................................. 37511.5 Beispiele ...................................................................................... 382

12 Sortierverfahren ....................................................................... 395

12.1 Bubblesort ................................................................................... 39612.2 Selectionsort ................................................................................ 39812.3 Insertionsort ................................................................................ 40112.4 Shellsort ...................................................................................... 40312.5 Quicksort ..................................................................................... 40712.6 Heapsort ...................................................................................... 41212.7 Leistungsanalyse .......................................................................... 418

12.7.1 Bubblesort .................................................................... 42012.7.2 Selectionsort ................................................................. 42112.7.3 Insertionsort ................................................................. 42312.7.4 Shellsort ........................................................................ 42412.7.5 Quicksort ...................................................................... 42512.7.6 Heapsort ....................................................................... 427


Inhalt

10

12.8 Vergleich und Bewertung ............................................................. 42812.9 Grenzen der Optimierung von Sortierverfahren ............................ 43412.10 Aufgaben ..................................................................................... 439

13 Datenstrukturen ....................................................................... 441

13.1 Datensequenz (struct) .................................................................. 44413.2 Datenalternative (union) .............................................................. 45113.3 Optimierung von Datenstrukturen ............................................... 45713.4 Zeiger und Datenstrukturen ......................................................... 46213.5 Dynamische Datenstrukturen ....................................................... 46513.6 Verkettete Datenstrukturen (Listen) ............................................. 47013.7 Die Freispeicherverwaltung .......................................................... 47413.8 Abstrakte Datentypen .................................................................. 478

13.8.1 Der abstrakte Datentyp »Stack« ..................................... 48013.8.2 Der abstrakte Datentyp »Queue« .................................. 485

13.9 Aufgaben ..................................................................................... 490

14 C-Referenz (Teil 2) .................................................................... 497

14.1 Einfache Strukturen ..................................................................... 49714.2 Zusammengesetzte Strukturen ..................................................... 50014.3 Zugriff auf Strukturen ................................................................... 502

14.3.1 Direkter Zugriff ............................................................. 50214.3.2 Indirekter Zugriff ........................................................... 503

14.4 Unions ......................................................................................... 50514.5 Datenstrukturen und Funktionen ................................................. 50614.6 Dynamische Datenstrukturen ....................................................... 50914.7 Zeiger in Datenstrukturen ............................................................ 51114.8 Typvereinbarungen ...................................................................... 51514.9 Bitfelder ...................................................................................... 516

15 Ausgewählte Datenstrukturen ................................................. 519

15.1 Aufgabenstellung ......................................................................... 51915.2 Schnittstellenvereinbarung ........................................................... 52115.3 Anwendungsprogramm ................................................................ 52415.4 Listen .......................................................................................... 530

15.4.1 Grundbegriffe ................................................................ 53015.4.2 Arrays oder Listen ......................................................... 53215.4.3 Speicherstruktur ............................................................ 533


Inhalt

11

15.4.4 Implementierung .......................................................... 53715.4.5 Test .............................................................................. 542

15.5 Bäume ......................................................................................... 54315.5.1 Grundbegriffe ................................................................ 54315.5.2 Traversierung von Bäumen ............................................ 54715.5.3 Speicherstruktur ............................................................ 55915.5.4 Implementierung .......................................................... 56215.5.5 Test .............................................................................. 569

15.6 Ausgeglichene Bäume .................................................................. 57015.6.1 Grundbegriffe ................................................................ 57115.6.2 Speicherstruktur ............................................................ 57515.6.3 Implementierung .......................................................... 57815.6.4 Test .............................................................................. 592

15.7 Hashtabellen ................................................................................ 59315.7.1 Grundbegriffe ................................................................ 59415.7.2 Speicherstruktur ............................................................ 59615.7.3 Implementierung .......................................................... 59915.7.4 Test .............................................................................. 602

15.8 Vergleich und Bewertung ............................................................. 60615.8.1 Speicherkomplexität ...................................................... 60615.8.2 Laufzeitmessungen ........................................................ 607

15.9 Aufgaben ..................................................................................... 612

16 Elemente der Graphentheorie .................................................. 613

16.1 Grundbegriffe .............................................................................. 61516.2 Darstellung von Graphen durch Datenstrukturen ......................... 62116.3 Ausgewählte graphentheoretische Probleme ................................ 627

16.3.1 Existenz von Wegen ...................................................... 62916.3.2 Kürzeste Wege .............................................................. 64916.3.3 Minimal spannende Bäume ........................................... 68216.3.4 Hamiltonsche Wege ...................................................... 688

17 Projekt 2D-Grafikprogrammierung .......................................... 701

18 C++-Referenz (Teil 1) ................................................................ 703

18.1 Schlüsselwörter ............................................................................ 70318.2 Operatoren .................................................................................. 70418.3 Kommentare ................................................................................ 70718.4 Datentypen, Datenstrukturen und Variablen ................................ 708


Inhalt

12

18.4.1 Automatische Typisierung von Aufzählungstypen .......... 70818.4.2 Automatische Typisierung von Strukturen ..................... 70818.4.3 Vorwärtsverweise auf Strukturen ................................... 70918.4.4 Der Datentyp bool ........................................................ 71018.4.5 Wide Character ............................................................. 71118.4.6 Const-Deklarationen ..................................................... 71218.4.7 Typumwandlungen ....................................................... 71318.4.8 Definition von Variablen ............................................... 71618.4.9 Referenzen .................................................................... 716

18.5 Funktionen und Operatoren ........................................................ 72218.5.1 Funktionsdeklarationen und Prototypen ........................ 72218.5.2 Default-Werte ............................................................... 72218.5.3 Inline-Funktionen ......................................................... 72418.5.4 Der Scope-Resolution-Operator .................................... 72518.5.5 Überladen von Funktionen ............................................ 72618.5.6 Überladen von Operatoren ........................................... 72818.5.7 Einbindung von C-Funktionen in C++-Programme ......... 730

18.6 Namensräume ............................................................................. 73218.6.1 Erstellung von Namensräumen ...................................... 73318.6.2 Verwendung von Namensräumen ................................. 73618.6.3 Der Namensraum std .................................................... 740

19 Objektorientierte Programmierung ......................................... 743

20 Klassen in C++ .......................................................................... 759

20.1 Aufbau von Klassen ..................................................................... 75920.1.1 Daten-Member ............................................................. 76120.1.2 Funktions-Member ....................................................... 76420.1.3 Konstruktoren und Destruktoren ................................... 772

20.2 Instantiierung von Klassen ........................................................... 77720.2.1 Automatische Instantiierung ......................................... 77920.2.2 Statische Instantiierung ................................................. 78120.2.3 Dynamische Instantiierung ............................................ 78220.2.4 Instantiierung von Arrays .............................................. 784

20.3 Friends ........................................................................................ 78520.4 Operatoren auf Klassen ................................................................ 78820.5 Ein- und Ausgabe in C++ ............................................................. 792

20.5.1 Bildschirmausgabe ........................................................ 793


Inhalt

13

20.5.2 Tastatureingabe ............................................................ 79620.5.3 Dateioperationen .......................................................... 797

20.6 Der this-Pointer ........................................................................... 79920.7 Beispiele ...................................................................................... 800

20.7.1 Menge .......................................................................... 80020.7.2 Bingo ............................................................................ 811

20.8 Aufgaben ..................................................................................... 818

21 Vererbung in C++ ..................................................................... 823

21.1 Geschützte Member .................................................................... 82921.2 Einfache Vererbung ..................................................................... 83221.3 Mehrfache Vererbung .................................................................. 83321.4 Instantiierung abgeleiteter Klassen ............................................... 83321.5 Erweiterung abgeleiteter Klassen ................................................. 83521.6 Überladen von Funktionen der Basisklasse ................................... 83621.7 Virtuelle Member-Funktionen ...................................................... 84121.8 Rein virtuelle Member-Funktionen .............................................. 84421.9 Statische Member ........................................................................ 84521.10 Beispiele ...................................................................................... 850

21.10.1 Würfelspiel ................................................................... 85021.10.2 Partnervermittlung ........................................................ 871

22 C++-Referenz (Teil 2) ................................................................ 893

22.1 Klassen und Instanzen ................................................................. 89322.2 Member ...................................................................................... 894

22.2.1 Daten-Member ............................................................. 89522.2.2 Funktions-Member ....................................................... 89622.2.3 Konstante Member ....................................................... 89922.2.4 Statische Member ......................................................... 90022.2.5 Operatoren ................................................................... 902

22.3 Zugriff auf Member ...................................................................... 90322.3.1 Zugriff von außen .......................................................... 90422.3.2 Zugriff von innen ........................................................... 90722.3.3 Der this-Pointer ............................................................ 91022.3.4 Zugriff durch Friends ..................................................... 911

22.4 Vererbung ................................................................................... 91322.4.1 Einfachvererbung .......................................................... 91322.4.2 Mehrfachvererbung ....................................................... 91722.4.3 Virtuelle Funktionen ..................................................... 922


Inhalt

14

22.4.4 Virtuelle Destruktoren ................................................... 92522.4.5 Rein virtuelle Funktionen .............................................. 92622.4.6 Dynamische Typüberprüfungen ..................................... 92822.4.7 Dynamische Typumwandlung ........................................ 929

22.5 Zugriffsschutz und Vererbung ...................................................... 93522.5.1 Geschützte Member ...................................................... 93622.5.2 Zugriff auf die Basisklasse .............................................. 93722.5.3 Modifikation von Zugriffsrechten .................................. 941

22.6 Der Lebenszyklus von Objekten ................................................... 94222.6.1 Konstruktion von Objekten ........................................... 94522.6.2 Destruktion von Objekten ............................................. 94822.6.3 Kopieren von Objekten ................................................. 94922.6.4 Instantiierung von Objekten .......................................... 95322.6.5 Implizite und explizite Verwendung von

Konstruktoren ............................................................... 95622.6.6 Initialisierung eingelagerter Objekte .............................. 95722.6.7 Initialisierung von Basisklassen ...................................... 96022.6.8 Initialisierung virtueller Basisklassen .............................. 96222.6.9 Instantiierungsregeln ..................................................... 964

22.7 Pointer to Member ...................................................................... 96622.8 Generische Klassen (Templates) ................................................... 97022.9 Ausnahmefallbehandlung ............................................................. 976

23 Die C++-Standard-Library ........................................................ 983

23.1 Iteratoren .................................................................................... 98423.2 Strings (string) ............................................................................. 987

23.2.1 Konstruktion ................................................................. 98823.2.2 Ein-/Ausgabe ................................................................ 98923.2.3 Zugriff ........................................................................... 98923.2.4 Manipulation ................................................................ 99223.2.5 Vergleich ...................................................................... 99723.2.6 Suchen .......................................................................... 99823.2.7 Speichermanagement .................................................... 999

23.3 Bitsets (bitset) .............................................................................. 100223.3.1 Konstruktion ................................................................. 100223.3.2 Zugriff ........................................................................... 100323.3.3 Manipulation ................................................................ 1004

23.4 Dynamische Arrays (vector) .......................................................... 100523.4.1 Konstruktion ................................................................. 100623.4.2 Zugriff ........................................................................... 1007


Inhalt

15

23.4.3 Iteratoren ...................................................................... 100823.4.4 Manipulation ................................................................ 100923.4.5 Speichermanagement .................................................... 1012

23.5 Beidseitige Warteschlangen (deque) ............................................ 101223.6 Listen (list) ................................................................................... 1014

23.6.1 Konstruktion ................................................................. 101423.6.2 Zugriff ........................................................................... 101523.6.3 Iteratoren ...................................................................... 101523.6.4 Manipulation ................................................................ 101723.6.5 Speichermanagement .................................................... 1027

23.7 Stacks (stack) ............................................................................... 102723.8 Warteschlangen (queue) .............................................................. 103023.9 Prioritätswarteschlangen (priority_queue) .................................... 103223.10 Geordnete Paare (pair) ................................................................. 103823.11 Mengen (set und multiset) ........................................................... 1040

23.11.1 Konstruktion ................................................................. 104123.11.2 Zugriff ........................................................................... 104223.11.3 Manipulation ................................................................ 1044

23.12 Relationen (map und multimap) .................................................. 104523.12.1 Konstruktion ................................................................. 104623.12.2 Zugriff ........................................................................... 104923.12.3 Manipulation ................................................................ 1049

23.13 Algorithmen der Standard-Library ................................................ 104923.13.1 Iterieren ........................................................................ 105223.13.2 Suchen und Finden ....................................................... 105323.13.3 Vergleichen ................................................................... 105523.13.4 Zählen ........................................................................... 105623.13.5 Kopieren ....................................................................... 105723.13.6 Tauschen ...................................................................... 105823.13.7 Ersetzen ........................................................................ 105923.13.8 Wertzuweisung ............................................................. 106123.13.9 Entfernen von Elementen .............................................. 106223.13.10 Reorganisation .............................................................. 106323.13.11 Sortieren ....................................................................... 106423.13.12 Binäre Suche ................................................................. 106523.13.13 Mischen ........................................................................ 106623.13.14 Mengenoperationen ..................................................... 106723.13.15 Heap-Algorithmen ........................................................ 106923.13.16 Minima und Maxima ..................................................... 107023.13.17 Lexikografische Ordnung und Permutationen ................ 1071

23.14 Vererbung und virtuelle Funktionen in Containern ....................... 1073


Inhalt

16

24 Projekt: 3D-Grafikprogrammierung ......................................... 1077

Anhang ........................................................................................... 1079

Lösungen ...................................................................................................... 1083Kapitel 1 ...................................................................................... 1085Kapitel 3 ...................................................................................... 1103Kapitel 4 ...................................................................................... 1123Kapitel 5 ...................................................................................... 1155Kapitel 6 ...................................................................................... 1169Kapitel 7 ...................................................................................... 1195Kapitel 8 ...................................................................................... 1245Kapitel 10..................................................................................... 1253Kapitel 12..................................................................................... 1273Kapitel 13..................................................................................... 1277Kapitel 15..................................................................................... 1305Kapitel 20..................................................................................... 1315

Index ........................................................................................................... 1333


21

1 Einige Grundbegriffe

Einem Kochbuch entnehmen wir das folgende Rezept zur Herstellung eines soge-nannten Pharisäers:

Das Rezept gliedert sich in zwei Teile. Im ersten Teil werden die erforderlichenZutaten genannt, und im zweiten Teil wird ein Verfahren beschrieben, nach demman aus den Zutaten das gewünschte Getränk herstellen kann. Die beiden Teilesind wesentlich verschieden und gehören doch untrennbar zusammen. Ohne Zu-taten ist die Zubereitung nicht durchführbar, und ohne Zubereitung bleiben dieZutaten ungenießbar. Zu beachten ist auch, dass sich der Autor bei der Erstellungdes Rezepts einer bestimmten Fachsprache (Essl., cl, Sahne steif schlagen, aufbrü-hen) bedient. Ohne diese Fachsprache wäre die Anleitung wahrscheinlich weit-schweifiger, umständlicher und vielleicht sogar missverständlich. Die Verwen-dung einer Fachsprache setzt allerdings voraus, dass sich Autor und Leser des Re-zepts zuvor (ausgesprochen oder unausgesprochen) auf eine gemeinsameTerminologie verständigt haben.

Wir übertragen dieses Beispiel in unsere Welt – die Welt der Datenverarbeitung:

� Die Zutaten für das Rezept sind die Daten bzw. Datenstrukturen, die wir ver-arbeiten wollen.

� Die Zubereitungsvorschrift ist ein Algorithmus1, der festlegt, wie die Daten zuverarbeiten sind.

Zutaten:1/2 l heißer Kaffee1/4 l Sahne2 Essl. Zucker4 Schnapsgläser 54%iger Rum (8 cl)

Zubereitung:Den Kaffee aufbrühen und warmhalten. 4 Tassen mit heißem Wasser vorwär-men. Inzwischen die Sahne steif schlagen. Das Wasser aus den Tassen gießen,die Tassen abtrocknen und in jede Tasse 1–2 Teelöffel Zucker geben. Je 1Schnapsglas Rum darüber gießen und mit dem Kaffee auffüllen. Die Schlag-sahne als Haube auf jede Tasse Pharisäer setzen.

1. Dieser Begriff geht zurück auf Abu Jafar Muhammad Ibn Musa Al-Khwarizmi, der alsBibliothekar des Kalifen von Bagdad um 825 ein Rechenbuch verfasste und dessen Namein der lateinischen Übersetzung von 1200 als »Algorithmus« angegeben wurde.


22

Einige Grundbegriffe1

� Das Rezept ist ein Programm, das alle Datenstrukturen (Zutaten) und Algorith-men (Zubereitungsvorschriften) zum Lösen der gestellten Aufgabe (Erstellendes Gerichts) enthält.

� Die gemeinsame Terminologie, in der sich Autor und Leser des Rezepts ver-ständigen, ist eine Programmiersprache, in der das Programm geschriebenist. Die Programmiersprache muss dabei in der Lage sein, alle bezüglich derZutaten und der Zubereitung bedeutsamen Informationen zweifelsfrei zuübermitteln.

� Die Küche ist die technische Infrastruktur zur Umsetzung von Rezepten inschmackhafte Gerichte und ist vergleichbar mit einem Computer, seinem Be-triebssystem und den benötigten Entwicklungswerkzeugen.

� Der Koch übersetzt das Rezept in einzelne Arbeitsschritte in der Küche. Übli-cherweise geht ein Koch in zwei Schritten vor. Im ersten Schritt bereitet er dieZutaten einzeln und unabhängig voneinander vor (z.B. Kartoffeln kochen), umdie Einzelteile dann in einem zweiten Schritt zusammenzufügen und abzu-schmecken. In der Datenverarbeitung sprechen wir in diesem Zusammenhangvon Compiler und Linker.

� Das fertige Gericht ist das lauffähige Programm, das vom Benutzer (Esser) an-gewandt (verzehrt) werden kann.

Nur, welche Rolle spielen wir in diesem Szenario? Sollte für uns kein Platz vorge-sehen sein? Wir suchen uns die interessantesten Aufgaben aus:

� Wir sind Autoren, die sich neue, schmackhafte Gerichte für unterschiedlicheAnlässe ausdenken und Rezepte bzw. Kochbücher mit den besten Kreationenveröffentlichen.

� Gelegentlich probieren wir auch einen Pharisäer, um uns an unseren eigenenSchöpfungen zu berauschen und um festzustellen, ob die Speise gelungen ist.

Was müssen wir lernen, um unsere Rolle ausfüllen zu können?

� Wir müssen die Sprache beherrschen, in der Rezepte formuliert werden.

� Wir müssen einen Überblick über die üblicherweise verwendeten Zutaten,deren Eigenschaften und Zubereitungsmöglichkeiten haben.

� Wir müssen einen Vorrat an Standard-Zubereitungsverfahren bzw. Rezeptenabrufbereit im Kopf haben.

� Wir müssen wissen, welche Zutaten oder Verfahren miteinander harmonierenund welche nicht.

� Wir müssen wissen, was in einer Küche üblicherweise an Hilfsmitteln vorhan-den ist und wie bzw. wozu diese Hilfsmittel verwendet werden.


23

Algorithmus 1.1

� Bei anspruchsvolleren Gerichten müssen wir wissen, in welcher Reihenfolgeund mit welchem Timing die Einzelteile zuzubereiten sind und wie die einzel-nen Aufgaben verteilt werden müssen, damit alles zeitgleich serviert werdenkann.

� Wir müssen auch wissen, worauf ein potentieller, späterer Esser Wert legt undworauf nicht. Dies ist besonders wichtig, wenn wir Rezepte für einen ganz be-sonderen Anlass erstellen.

Letztlich wollen wir komplette Festmenüs und deren Speisefolge komponierenund benötigen dazu eine Mischung aus Phantasie, Kreativität, logischer Strenge,Ausdauer und Fleiß, wie sie auch ein guter Komponist oder Architekt benötigt.

Zurück zu den Grundbegriffen der Informatik. Wir haben informell die Begriffe

� Datenstruktur,

� Algorithmus und

� Programm

eingeführt und dabei bereits erkannt, dass diese Begriffe untrennbar zusammen-gehören und eigentlich nur unterschiedliche Facetten ein und desselben Themen-komplexes sind.

� Algorithmen arbeiten auf Datenstrukturen. Algorithmen ohne Datenstruktu-ren sind leere Formalismen.

� Datenstrukturen benötigen Algorithmen, die auf ihnen operieren und sie da-mit zum »Leben« erwecken.

� Programme realisieren Datenstrukturen und Algorithmen. Algorithmen undDatenstrukturen sind zwar ohne Programme denkbar, aber viele Datenstruktu-ren und Algorithmen wären ohne Programmierung allenfalls von akademi-schem Interesse.

In einem ersten Wurf versuchen wir, die Begriffe »Algorithmus«, »Datenstruktur«und »Programm« einigermaßen exakt zu erfassen.

1.1 Algorithmus

Um unsere noch sehr vage Vorstellung von einem Algorithmus zu präzisieren,starten wir mit einer Definition:

Ein Algorithmus ist eine endliche Menge von genau beschriebenen Anwei-sungen, die unter Benutzung von vorgegebenen Anfangsdaten in einer genaufestgelegten Reihenfolge auszuführen sind, um die Lösung eines Problems inendlich vielen Schritten zu ermitteln.


24


Bei dem Begriff »Algorithmus« denkt man heute sofort an »Programmierung«.Das war nicht immer so. In der Tat gab es Algorithmen schon lange, bevor manauch nur entfernt an Programmierung dachte. Bereits im antiken Griechenlandwurden Algorithmen zur Lösung mathematischer Probleme formuliert, so zumBeispiel der Euklidische Algorithmus zur Bestimmung des größten gemeinsamenTeilers zweier Zahlen oder das sogenannte Sieb des Eratosthenes zur Bestimmungaller Primzahlen unterhalb einer vorgegebenen Schranke.2

Ihnen ist der Algorithmus zur schrittweisen Berechnung des Quotienten zweierZahlen schon lange vertraut. Um beispielsweise 84 durch 16 zu dividieren, gehtman wie folgt vor:

Wenn wir versuchen, dieses Verfahren im Detail zu beschreiben, finden wir allein der obigen Definition genannten Elemente wieder:

Problem:

Berechne den Quotienten zweier natürlicher Zahlen!

Anfangsdaten:

z = Zähler (z ≥ 0),n = Nenner (n > 0) unda = Anzahl der zu berechnenden Nachkommastellen.3

Anweisungen:

1. Bestimme die größte ganze Zahl x mit nx ≤ z! Dies ist der Vorkomma-Anteil der gesuchten Zahl.

2. Zur Bestimmung der Nachkommastellen fahre wie folgt fort:

2.1 Sind noch Nachkommastellen zu berechnen (d.h. a > 0)? Wennnein, dann beende das Verfahren!

2.2 Setze z = 10(z-nx)!

2.3 Ist z = 0, so beende das Verfahren!

2. Eukleides von Alexandria (um 300 vor Chr.) und Erathostenes von Kyrene (um 200 vorChr.).

84:16=5,2580403280800

3. Anfänglich ist a die Anzahl der zu berechnenden Nachkommastellen. Im Verfahren ver-wenden wir a als die Anzahl der noch zu berechnenden Nachkommastellen. Wir werdenden Wert von a in jedem Verfahrensschritt herunterzählen, bis a = 0 ist und keine Nach-kommastellen mehr zu berechnen sind.


25

Algorithmus 1.1

2.4 Bestimme die größte ganze Zahl x mit nx ≤ z! Dies ist die nächsteZiffer.

2.5 Jetzt ist eine Ziffer weniger zu bestimmen. Vermindere also den Wertvon a um 1 und fahre anschließend bei 2.1 fort!

Die einzelnen Anweisungen und ihre Abfolge können wir uns durch ein soge-nanntes Flussdiagramm veranschaulichen. In einem solchen Diagramm werdenalle beim Ablauf des Algorithmus möglicherweise vorkommenden Wege unterVerwendung bestimmter Symbole grafisch beschrieben. Die dabei zulässigenSymbole sind in einer Norm (DIN 66001) festgelegt. Von den zahlreichen in derNorm festgelegten Symbolen wollen wir hier nur einige einführen:

Mit diesen Symbolen können wir den zuvor nur sprachlich beschriebenen Algo-rithmus auch grafisch darstellen, wenn wir zusätzlich die Abfolge der einzelnenOperationen durch Richtungspfeile kennzeichnen.

Start/Ende des Algorithmus

Ein-/Ausgabe

Allgemeine Operation

Verzweigung

Ende

Eingabe: z, n, a

Start

x = größte ganze Zahlmit nx ≤ z

Ausgabe: "Ergebnis = x."

z = 10 (z - nx)

z = 0? ja

x = größte ganze Zahlmit nx ≤ z

Ausgabe: "x"

a = a-1

ja

nein

nein

1

2.2

2.3

2.4

2.5

a > 0?

2.1


26


In der vorherigen Grafik können wir den Ablauf des Algorithmus für konkreteAnfangswerte »mit dem Finger« nachfahren und erhalten so eine recht gute Vor-stellung von der Dynamik des Verfahrens.

Wir wollen den Divisionsalgorithmus anhand des Flussdiagramms für konkreteDaten (z=84, n=16, a=4) Schritt für Schritt durchführen. Mehrfach durchlau-fene Teile zeichnen wir dabei entsprechend oft, nicht durchlaufene Pfade lassenwir weg.

Als Ergebnis erhalten wir die Ausgabe "5.25". Wir sehen, dass der Algorithmusgewisse Verfahrensschritte (z.B. 2.1) mehrfach, allerdings mit verschiedenen Da-ten durchläuft. Die Daten steuern letztlich den konkreten Ablauf des Algorith-mus. Das Verfahren zeigt im Ablauf eine gewisse Regelmäßigkeit – um nicht zusagen Monotonie. Gerade solche monotonen Aufgaben würde man sich gern von

Eingabe:z=84, n=16, a=4

Start

x = größte ganze Zahlmit 16x ≤ 84 = 5

Ausgabe: "5."

z = 10 (84 - 16*5) = 40

z = 0 ? Ende

x = größte ganze Zahlmit 16x ≤40 = 2

Ausgabe: "2"

a = 4-1 = 3

a > 0 ?

1

2.2

2.3

2.4

2.5

z = 10 (80 -16*5) = 0

z = 0 ?

nein

ja

ja

1. Durchlauf 3. Durchlauf

a > 0 ?

ja

2.1

z = 10 (40 - 16*2) = 80

z = 0 ?

x = größte ganze Zahlmit 16x ≤ 80 = 5

Ausgabe: "5"

a = 3-1 = 2

a > 0 ?

nein

ja

2. Durchlauf


27

Datenstruktur 1.2

einer Maschine abnehmen lassen. Eine Maschine müsste natürlich jeden einzel-nen Verfahrensschritt »verstehen« können, um das Verfahren als Ganzes durch-führen zu können. Einige unserer Schritte (z.B. 2.2) erscheinen unmittelbar ver-ständlich, während andere (z.B. 2.4) ein gewisses mathematisches Vorverständnisvoraussetzen. Je nachdem, welche Eigenintelligenz man bei demjenigen (Menschoder Maschine) voraussetzt, der den Algorithmus durchführen soll, wird man anmanchen Stellen noch präziser formulieren und einen Verfahrensschritt gegebe-nenfalls in einfachere Teilschritte zerlegen müssen.

Festgehalten werden sollte noch, dass wir von einem Algorithmus gefordert ha-ben, dass er nach endlich vielen Schritten zu einem Ergebnis kommt (terminiert).Dies ist bei unserem Divisionsalgorithmus durch die Vorgabe der Anzahl der zuberechnenden Nachkommastellen sichergestellt, auch wenn in unserem konkre-ten Beispiel ein vorzeitiger Abbruch eintritt. Würden wir das Abbruchkriteriumfallenlassen, so würde unser Verfahren unter Umständen (z.B. bei der Berech-nung von 10:3) nicht abbrechen, und eine mit der Berechnung beauftragteMaschine würde endlos rechnen. Es ist zu befürchten, dass die Eigenschaft desTerminierens für manche Verfahren schwer oder vielleicht gar nicht nachzuwei-sen ist.

1.2 Datenstruktur

Wir wenden uns jetzt dem Begriff der »Datenstruktur« zu.

Eine Datenstruktur ist ein Modell, das die zur Lösung eines Problems benö-tigten Informationen (Ausgangsdaten, Zwischenergebnisse, Endergebnisse)enthält und für alle Informationen genau festgelegte Zugriffswege bereitstellt.

Auch Datenstrukturen hat es bereits lange vor der Programmierung gegeben, ob-wohl man hier mit einigem Recht sagen kann, dass die Theorie der Datenstruktu-ren erst mit der maschinellen Datenverarbeitung zur Blüte gekommen ist.

Als Beispiel betrachten wir ein Versandhaus, das seine Geschäftsvorfälle durchdrei Karteien organisiert. Die Kundenkartei enthält die personenbezogenen Da-ten aller Kunden. Die Artikelkartei enthält die Stammdaten und den Lagerbestandaller lieferbaren Artikel. In der Bestellkartei schließlich werden alle eingehendenBestellungen festgehalten.


28


Ein einzelner Datensatz entspricht einer ausgefüllten Karteikarte. Auf jeder Kar-teikarte sind zwei Bereiche erkennbar. Links steht jeweils die Struktur der Daten,während rechts die konkreten Datenwerte stehen. Die Datensätze für Kunden,Artikel und Bestellungen sind dabei strukturell verschieden. Neben der Strukturder Karteikarten ist natürlich auch noch die Organisation der einzelnen Karteikäs-ten von Bedeutung. Wir stellen uns vor, dass die Kundendatei nach Kundennum-mern, die Artikeldatei nach Artikelnummern und die Bestelldatei nach Bestellda-tum sortiert ist. Darüber hinaus gibt es noch Querverweise zwischen den Daten-sätzen der verschiedenen Karteikästen. In der Bestelldatei finden wir auf jederKarteikarte beispielsweise Artikelnummern und eine Kundennummer. Die dreiKarteikästen mit ihrer Sortierung, der Struktur ihrer Karteikarten und der Quer-verweisstruktur bilden insgesamt die Datenstruktur. Beachten Sie, dass die kon-kreten Daten nicht zur Datenstruktur gehören. Die Datenstruktur legt nur die Or-ganisationsform der Daten fest, nicht jedoch die konkreten Datenwerte. Auf derDatenstruktur arbeiten dann gewisse Algorithmen (z.B. Kundenadresse ändern,Rechnung stellen, Artikel nachbestellen, Lieferung zusammenstellen usw.). DieEffizienz dieser Algorithmen hängt dabei ganz entscheidend von der Organisa-tion der Datenstruktur ab. Zum Beispiel ist die Frage: »Was hat der Kunde Müllerdem Unternehmen bisher an Umsatz gebracht?«, ausgesprochen schwer zu beant-worten. Dazu muss man zunächst in der Kundendatei die Kundennummer desKunden Müller finden. Dann muss man alle Bestellungen durchsuchen, um fest-zustellen, ob die Kundennummer von Müller dort vorkommt, und schließlichmuss man dann noch die Preise der in den betroffenen Bestellungen vorkommen-den Artikel in der Artikeldatei suchen und aufsummieren. Die Frage: »Welche Ar-tikel in welcher Menge sind im letzen Monat bestellt worden?«, lässt sich mit die-ser Datenstruktur erheblich einfacher beantworten.

Kunde: 1234Datum: 15.09.1996Bestellung

Artikel: P23-914/6Anzahl: 1Artikel: ...Anzahl: ...

. ..

Bestellung

Bezeichnung: DruckerArt. Nr.: P23-914/6Lagerbestand: 43EK-Preis: 375.00VK-Preis: 498.00

ArtikelKundennummer: 1234Name: MeierVorname: OttoAdresse: ...

Kunde


29

Programm 1.3

Das Problem, eine »bestmögliche« Organisationsform für eine Datenstruktur zufinden, ist im Allgemeinen unlösbar, weil man dazu in der Regel gegenläufige Op-timierungsaspekte in Einklang bringen muss. Man könnte zum Beispiel bei derobigen Datenstruktur den Verbesserungsvorschlag machen, alle Kundendaten mitauf der Bestellkartei zu vermerken, um die Rechnungsstellung zu erleichtern. Da-durch erhöht sich dann aber der Aufwand, den man bei der Adressänderung ei-nes Kunden in Kauf zu nehmen hat. Die Erstellung von Datenstrukturen, die alleAlgorithmen eines bestimmten Problemfeldes wirkungsvoll unterstützen, ist eineausgesprochen schwierige Aufgabe, zumal man häufig zum Zeitpunkt der Festle-gung einer Datenstruktur noch gar nicht absehen kann, welche Algorithmen inZukunft mit den Daten dieser Struktur arbeiten werden.

Bei der Fülle der in der Praxis vorkommenden Probleme und Strukturen (Kun-dendaten, Geschäftsprozesse, Stücklisten technischer Bauteile, Versicherungsver-träge, Krankengeschichten, Konstruktionszeichnungen, Verdachtsflächen für Alt-lasten, Aktienkurse, ...) kann man natürlich nicht erwarten, dass man für alle (janicht einmal für die hier genannten) Beispiele passende Datenstrukturen bereit-stellen kann. Wir müssen lernen, typische, immer wiederkehrende Bausteine zuidentifizieren und zu beherrschen. Aus diesen Bausteinen werden wir dann kom-plexere, jeweils an ein bestimmtes Problem angepasste Strukturen aufbauen.

1.3 Programm

Ein Programm ist im Gegensatz zu einer Datenstruktur oder einem Algorithmusfür uns etwas sehr Konkretes – zumindest dann, wenn wir schon einmal ein Pro-gramm erstellt oder benutzt haben.

Ein Programm ist eine eindeutige, formalisierte Beschreibung von Algorith-men und Datenstrukturen, die durch einen automatischen Übersetzungspro-zess auf einem Computer ablauffähig ist.

Den zur Formulierung eines Programms verwendeten Beschreibungsformalis-mus bezeichnen wir als Programmiersprache.

Im Gegensatz zu einem Algorithmus fordern wir von einem Programm nicht ex-plizit, dass es terminiert. Viele Programme (z.B. ein Betriebssystem oder Pro-gramme zur Überwachung und Steuerung technischer Anlagen) sind auch so kon-zipiert, dass sie im Prinzip endlos laufen könnten.

Eine Programmiersprache muss nach unserer Definition Elemente zur exaktenBeschreibung von Datenstrukturen und Algorithmen enthalten. Programmier-sprachen dienen uns daher nicht nur zur Erstellung lauffähiger Programme, son-dern auch zur präzisen Festlegung von Datenstrukturen und Algorithmen.


30


Eigentlich stellen wir gegensätzliche Forderungen an eine Programmiersprache.Sie sollte

� automatisch übersetzbar, d.h. maschinenlesbar und

� möglichst verständlich und leicht erlernbar, d.h. menschenlesbar

sein, und sie sollte darüber hinaus die maschinellen Berechnungs- und Verarbei-tungsmöglichkeiten eines Computers möglichst vollständig ausschöpfen. Maschi-nenlesbarkeit und Menschenlesbarkeit sind bei den heutigen Maschinenkonzep-ten unvereinbare Begriffe. Da die Maschinenlesbarkeit jedoch unverzichtbar ist,müssen zwangsläufig bei der Menschenlesbarkeit Kompromisse gemacht wer-den; Kompromisse, von denen Berufsgruppen wie Systemanalytiker oder Pro-grammierer leben.

Häufig teilt man Programmiersprachen in

� maschinenorientierte,

� universelle und

� spezielle

Sprachen ein.

Maschinenorientiert nennen wir Sprachen, die Annahmen über konkrete Merk-male einer Rechnerarchitektur (z.B. Adressierungsmöglichkeiten, Register, Stack,Prozessor-Status, Hardware-Interrupts) machen. Wir werden solche Sprachen imRahmen dieses Buches nicht betrachten.

Um die Frage nach der »Mächtigkeit« von Programmiersprachen zu beantworten,wurden in der theoretischen Informatik zahlreiche Berechnungs- bzw. Program-mierformalismen aufgestellt4. Es konnte gezeigt werden, dass diese Formalismenalle exakt die gleiche Klasse von Problemen lösen und damit von gleicher Mäch-tigkeit sind. Programmiersprachen dieser Mächtigkeit werden als universell be-zeichnet. Zu den universellen Programmiersprachen gehören u.a. Ada, Basic, C,C++, Cobol, Fortran, Java, Lisp, Modula-2, Pascal und Prolog. Diese Liste ließesich problemlos weiter fortsetzen. Universelle Sprachen stehen im Mittelpunktunserer Betrachtungen, auch wenn wir uns in konkreten Beispielen ausschließ-lich mit C bzw. C++ beschäftigen.

Manche Programmiersprachen geben die Universalität auf, um spezielle Pro-bleme effizienter oder komfortabler lösen zu können. Solche Sprachen bezeich-nen wir als spezielle Programmiersprachen. Beispiele sind etwa UIL zur Spezifi-kation von grafischen Benutzeroberflächen, SQL zur Arbeit mit relationalen Da-tenbanken oder die Kommandosprache zur Bedienung eines DOS-Systems.

4. Z.B. die »Turingmaschine«


31

Programm 1.3

Solche Sprachen sind oft rein deskriptiv (beschreibend) und enthalten keine ex-pliziten Steueranweisungen. Auch mit solchen Sprachen beschäftigen wir unshier nicht.

Die verschiedenen Programmiersprachen, die wir heute verwenden, haben sichnicht unabhängig voneinander entwickelt. Sie sind teilweise auseinander hervor-gegangen oder haben sich wechselseitig beeinflusst. Auf diese Weise entsteht ein»Stammbaum«, der für einige wichtige universelle Programmiersprachen in derfolgenden Grafik dargestellt ist:

Der Stammbaum zeigt die prägende Bedeutung, die Fortran und Algol für die Ent-wicklung der Programmiersprachen hatten. Einige eigenständige und für die In-formatik durchaus interessante Programmierkonzepte (z.B. Prolog) fristen bei derpraktischen Anwendung ein Schattendasein. Erwähnt werden sollte die beson-dere Bedeutung der Programmiersprache Cobol, die – oft für tot erklärt – im Be-reich der kommerziellen Software bei Banken und Versicherungen immer nochverwendet wird.

Alle hier aufgeführten Programmiersprachen sind im oben angesprochenen Sinnuniversell und daher gleich mächtig. Prinzipiell ist es daher egal, in welcher dieserSprachen wir unsere Programme formulieren. Die Entscheidung für die Verwen-dung von C/C++ in diesem Buch hat ausschließlich praktische Gründe. Insbeson-dere ist hier die hohe Verbreitung von C/C++ im Bereich der technischen Pro-grammierung zu nennen. Als Alternative zu C/C++ bietet sich Java an. Es ist je-doch festzustellen, dass C/C++ und Java so eng miteinander verwandt sind, dass

1950

1960

1970

1980

1990

Fortran

Cobol Algol

PL/1

Pascal

C

Simula

Smalltalk

Ada

C++Eiffel

Lisp

ML

Miranda

Prolog

BasicBCPL

Modula-2

Oberon

Java

2000


32


Ihnen ein gegebenenfalls erforderlicher Umstieg von der einen auf die andereSprache nicht schwer fallen wird.

1.4 Aufgaben

A 1.1 Formulieren Sie Ihr morgendliches Aufsteh-Ritual vom Klingeln des We-ckers bis zum Verlassen des Hauses als Algorithmus. Berücksichtigen Siedabei auch verschiedene Wochentags-Varianten! Zeichnen Sie ein Fluss-diagramm!

A 1.2 Verfeinern Sie den Algorithmus zur Division zweier Zahlen aus Abschnitt1.1 so, dass er von jemandem, der nur Zahlen addieren, subtrahieren undder Größe nach vergleichen kann, durchgeführt werden kann! ZeichnenSie ein Flussdiagramm!

A 1.3 In unserem Kalender sind zum Ausgleich der astronomischen und der ka-lendarischen Jahreslänge in regelmäßigen Abständen Schaltjahre einge-baut. Zur exakten Festlegung der Schaltjahre dienen die folgenden Re-geln:

(1) Ist die Jahreszahl durch 4 teilbar, so ist das Jahr ein Schaltjahr.

Diese Regel hat allerdings eine Ausnahme:

(2) Ist die Jahreszahl durch 100 teilbar, so ist das Jahr kein Schaltjahr.

Diese Ausnahme hat wiederum eine Ausnahme:

(3) Ist die Jahreszahl durch 400 teilbar, so ist das Jahr doch ein Schaltjahr.

Formulieren Sie einen Algorithmus, mit dessen Hilfe man feststellenkann, ob ein bestimmtes Jahr ein Schaltjahr ist oder nicht!

A 1.4 Sie sollen eine unbekannte Zahl x (1 ≤ x ≤ 1000) erraten und habenbeliebig viele Versuche dazu. Bei jedem Versuch erhalten Sie die Rückmel-dung, ob die gesuchte Zahl größer, kleiner oder gleich der von Ihnen ge-ratenen Zahl ist. Entwickeln Sie einen Algorithmus, um die gesuchte Zahlmöglichst schnell zu ermitteln! Wie viele Versuche benötigen Sie bei Ih-rem Verfahren maximal?

A 1.5 Formulieren Sie einen Algorithmus, der prüft, ob eine gegebene Zahl einePrimzahl ist oder nicht!

A 1.6 Ihr CD-Ständer hat 100 Fächer, die fortlaufend von 1–100 nummeriertsind. In jedem Fach befindet sich eine CD. Formulieren Sie einen Algo-rithmus, mit dessen Hilfe Sie die CDs alphabetisch nach Interpreten sor-


33

Aufgaben 1.4

tieren können! Das Verfahren soll dabei auf den beiden folgenden Grund-funktionen basieren:

vergleiche(n,m)

Vergleiche die Interpreten der CDs in den Fächern n und m! Ergebnis:»richtig« oder »falsch« je nachdem, ob die beiden CDs in der richtigenoder falschen Reihenfolge im Ständer stehen.

tausche(n,m)

Tausche die CDs in den Fächern n und m!

A 1.7 Formulieren Sie einen Algorithmus, mit dessen Hilfe Sie die CDs in IhremCD-Ständer jeweils um ein Fach aufwärts verschieben können! Die dabeiam Ende herausgeschobene CD kommt in das erste Fach. Das Verfahrensoll nur auf der Grundfunktion tausche aus Aufgabe 1.6 beruhen.

A 1.8 Formulieren Sie einen Algorithmus, mit dessen Hilfe Sie die Reihenfolgeder CDs in Ihrem CD-Ständer umkehren können! Das Verfahren soll nurauf der Grundfunktion tausche aus Aufgabe 1.6 beruhen.

A 1.9 In einem Hochhaus mit 20 Stockwerken fährt ein Aufzug. Im Aufzug sind20 Knöpfe, mit denen man sein Fahrziel wählen kann, und auf jeder Etageist ein Knopf, mit dem man den Aufzug rufen kann. Entwickeln Sie einenAlgorithmus, der den Aufzug so steuert, dass alle Aufzugbenutzer gerechtbedient werden! Sie können dabei annehmen, dass der Aufzug über diefolgenden Befehle zur Fahrtsteuerung bzw. zum Auslesen der Bedienele-mente verfügt:

fahre(n)

Fahre das Stockwerk n an!

lade()

Lade oder entlade in dem zuletzt angefahrenen Stockwerk Fahrgäste!

pruefe(n)

Prüfe, ob Stockwerk n (innen oder außen) als Fahrziel gewählt wurde!Ergebnis: »ja« oder »nein«.

max()

Liefert die höchste Etage, die aktuell als Fahrziel (innen oder außen)gewählt wurde. Ergebnis: Etagennummer.

min()

Liefert die niedrigste Etage, die aktuell als Fahrziel (innen oder außen)gewählt wurde. Ergebnis: Etagennummer.

loesche(n)

Löscht Etage n als Fahrziel.


34


A 1.10 Beim Schach gibt es ein einfaches Endspiel:

Versuchen Sie den Algorithmus für das Endspiel so zu formulieren, dassauch ein Nicht-Schachspieler die Spielstrategie versteht!

König und Turm gegen König


Lösu

ngen

Lösungen


1085

Kapitel 1

Lösu

ngen

Kapitel 1

A 1.1 Formulieren Sie Ihr morgendliches Aufsteh-Ritual vom Klingeln des We-ckers bis zum Verlassen des Hauses als Algorithmus. Berücksichtigen Siedabei auch verschiedene Wochentags-Varianten! Zeichnen Sie ein Fluss-diagramm!

Vorüberlegung:

Natürlich haben wir alle unterschiedliche »Aufsteh-Rituale«, jedoch ist es hierwichtig, sich möglichst genaue Gedanken über den zeitlichen Ablauf des typi-schen Morgens zu machen. Sehr leicht werden Sie dabei erkennen, wie viele un-bewusste Entscheidungspfade ein auf den ersten Blick so simpler Vorgang wie dastägliche Aufstehen beinhaltet.

Lösungsteil 1 ( Algorithmus ):

1. Stelle den Wecker aus!

2. Ist der heutige Wochentag ein Samstag oder ein Sonntag, dann schlaf ruhigweiter!

Andernfalls fahre mit Punkt 3 fort!

3. Ist das Badezimmer gerade besetzt, dann warte solange, bis es frei wird!

3.1 Ist dies nicht der Fall, dann kannst Du jetzt duschen und Dich danach an-ziehen!

4. Ist das Frühstück von keinem anderen bereits vorbereitet worden, musst Du eswohl selbst tun!

4.1 Andernfalls kannst Du sofort Dein Frühstück zu Dir nehmen!

5. Ist das Badezimmer gerade besetzt, dann warte solange, bis es frei wird!

5.1 Ist dies nicht der Fall, dann kannst Du Dir nun Deine Zähne putzen!

6. Nun musst Du nur noch Deine Schuhe und Jacke anziehen,

6.1 die Schulsachen mitnehmen

6.2 und das Haus in Richtung Schule verlassen!


Kapitel 1

1086

Lösu

ngen

Lösungsteil 2 (Flussdiagramm)

A 1.2 Verfeinern Sie den Algorithmus zur Division zweier Zahlen aus Abschnitt1.1 so, dass er von jemandem, der nur Zahlen addieren, subtrahieren undder Größe nach vergleichen kann, durchgeführt werden kann! ZeichnenSie ein Flussdiagramm!

Vorüberlegung:

Zuallererst sollten wir uns genau den Algorithmus aus Abschnitt 1.1 anschauen.Das Ziel ist, die Stellen herauszufinden, an denen die obigen Bedingungen nichterfüllt werden. Wir suchen also die Anweisungen heraus, in denen andere Ope-

5

5.1

6

6.1

6.2

4

4.1

3

3.1

2

1

Start

Welcher Wochentag?

Wecker ausstellen

Anziehen

Frühstück fertig?

Frühstücken

Badezimmer besetzt?

Warten

Zähne putzen

Badezimmer besetzt ?

Warten

Duschen

Jacke und Schuhe anziehen

Schulsachen mitnehmen

Frühstück vorbereiten

Weiterschlafen

Haus verlassen

Montag bis Freitag Sam/Sonn

ja

nein

ja

ja

nein

nein


1087

Kapitel 1

Lösu

ngen

rationen als Addition, Division oder ein Vergleich verwendet werden. Diese wer-den wir dann so umformulieren, dass sie nur noch die in der Aufgabenstellungerlaubten Operationen verwenden.

Der ursprüngliche Algorithmus:

Problem:


Anfangsdaten:

z = Zähler ( z ≥ 0 )n = Nenner ( n > 0 ) unda = Anzahl der zu berechnenden Nachkommastellen.

Anweisungen:

1. Bestimme die größte ganze Zahl x mit n·x ≤ z! Dies ist der Vorkommaanteilder gesuchten Zahl.


2.1 Sind noch Nachkommastellen zu berechnen (d. h. a > 0)? Wenn nein,dann beende das Verfahren!

2.2 Setze z = 10(z-n·x)!


2.4 Bestimme die größte ganze Zahl x mit n·x ≤ z! Dies ist die nächste Ziffer.

2.5 Jetzt ist eine Ziffer weniger zu bestimmen. Vermindere also den Wert vona um 1 und fahre anschließend bei 2.1 fort!

Die Anweisungen 1 und 2.4 enthalten eine Division, denn um die geforderte Zahlx zu bestimmen, müssen wir die Operation x = z/n durchführen. Dies ist durchdie Aufgabenstellung nicht erlaubt. Um diese Anweisungen zu ersetzen, benöti-gen wir eine zusätzliche Variable y. Wir werden y solange um den Wert des Nen-ners n erhöhen, bis wir den Wert des Zählers z übertroffen haben.

Wir ersetzen diese Anweisungen also durch:

1. Um die größte Zahl x mit n·x ≤ z zu bestimmen, fahre wie folgt fort:

1.1 Setze x = 0 und y = n!

1.2 Ist y > z, so ist x der gesuchte Vorkommaanteil!

1.3 Ist dies nicht der Fall, dann setze x = x+1 und y = y+n und fahre mitPunkt 1.2 fort!

Die Anweisung 2.2 enthält zwei Multiplikationen: n·x und 10·Klammerinhalt.


Kapitel 1

1088

Lösu

ngen

Den Wert n·x können wir aus y berechnen. Unser y ist um den Wert des Nennersn zu hoch, denn wir mussten ihn solange erhöhen, bis wir über den Wert des Zäh-lers z hinausgekommen sind, also einmal zu viel. Deshalb können wir n·x ein-fach durch y-n ersetzen.

Die Multiplikation des Klammerinhalts mit 10 lassen wir verschwinden, indemwir den Klammerinhalt in einer Zwischenvariablen k speichern und ihn zehnmalin der Variable add aufaddieren. Wie oft wir schon addiert haben, zählen wir inder Variablen i mit.

Somit ergeben sich für die Anweisung 2.2 folgende Algorithmusanweisungen:

2.2 Setze add = 0 und i = 1!

2.3 Speichere den Klammerinhalt z–(y-n) in der Variablen k, setze alsok = z–(y-n)!

2.4 Solange die Zählvariable i ≤ 10 ist

2.4.1 Addiere k zu add und

2.4.2 Erhöhe den Wert von i um 1!

2.5 Setze z = add!

Der neue Algorithmus:

Problem:


Anfangsdaten:

z = Zähler (z � 0)

n = Nenner (n > 0)a = Anzahl der zu berechnenden Nachkommastellen

i = Zählvariabley = Zwischenspeicher für n·xk = Zwischenspeicher für den Inhalt der ursprünglichen Klammer (z-n·x)add = Zwischenspeicher für die Aufaddierung des Klammerwertes

Anweisungen:



1.2 Ist y > z, so ist x der gesuchte Vorkommaanteil!

1.3 Ist dies nicht der Fall, dann erhöhe den Wert von x um 1, den Wert von yum den Wert des Nenners n und fahre mit Punkt 1.2 fort!


1089

Kapitel 1

Lösu

ngen


2.1 Sind noch Nachkommastellen zu berechnen (d. h. a > 0)? Wenn nein,dann beende das Verfahren!

2.2 Setze add = 0, i = 1 und speichere den Klammerinhalt z-(y-n) in derVariablen k, setze also k = z-(y-n)!

2.3 Solange die Zählvariable i ≤ 10 ist, addiere k zu add und erhöhe denWert von i um 1!

2.4 Setze z = add !




3.2 Ist y > z, so ist x die nächste Ziffer!

3.3 Ist dies nicht der Fall, dann erhöhe den Wert von x um 1, den Wert von yum den Wert des Nenners n und fahre mit Punkt 3.2 fort!

4. Jetzt ist eine Ziffer weniger zu bestimmen. Vermindere also den Wert von aum 1 und fahre anschließend bei 2.1 fort!


Kapitel 1

1090

Lösu

ngen

Das Flussdiagramm:

A 1.3 In unserem Kalender sind zum Ausgleich der astronomischen und derkalendarischen Jahreslänge in regelmäßigen Abständen Schaltjahre einge-baut. Zur exakten Festlegung der Schaltjahre dienen die folgendenRegeln:

4

3.3 3.2

3.1

2.5

2.4

2.3

2.22.1

1.31.2

1.1

Start

Eingabe: z, n, a

x = 0, y = n

y > z? x = x + 1y = y + n

Ausgabe:„Ergebnis: x.“

a > 0 ?

Endeadd = 0, i = 1

k = z-(y-n)

i ≤ 10 ?

add = add +ki = i + 1

z = add

z = 0 ?Ende

x = 0, y = n

y > z ?x = x + 1y = y + n

Ausgabe: „x“ a = a - 1

nein

nein

nein

ja

ja

ja

nein

nein

ja

ja


1091

Kapitel 1

Lösu

ngen

(1) Ist die Jahreszahl durch 4 teilbar, so ist das Jahr ein Schaltjahr.

Diese Regel hat allerdings eine Ausnahme:

(2) Ist die Jahreszahl durch 100 teilbar, so ist das Jahr doch keinSchaltjahr.

Diese Ausnahme hat wiederum eine Ausnahme:

(3) Ist die Jahreszahl durch 400 teilbar, so ist das Jahr doch einSchaltjahr.

Formulieren Sie einen Algorithmus, mit dessen Hilfe man feststellenkann, ob ein bestimmtes Jahr ein Schaltjahr ist oder nicht!

Vorüberlegung:

Wir können diesen Algorithmus bereits anhand der Aufgabenstellung, die bereitsdas gesamte Regelwerk enthält herausarbeiten:

Einsetzen der ersten Regel:

Einsetzen der zweiten Regel:

Regel 1Start

Durch 4 teilbar ?

Ausgabe: „Kein Schaltjahr“

Ausgabe: „Schaltjahr“

Ende

janein

Regel 1Start

Durch 4 teilbar ?


Ende

Regel 2Durch 100 teilbar ?



nein

nein

ja

ja


Kapitel 1

1092

Lösu

ngen

Einsetzen der dritten Regel:

A 1.4 Sie sollen eine unbekannte Zahl x (1 ≤ x ≤ 1000) erraten und habenbeliebig viele Versuche dazu. Bei jedem Versuch erhalten Sie die Rückmel-dung, ob die gesuchte Zahl größer, kleiner oder gleich der von Ihnen ge-ratenen Zahl ist. Entwickeln Sie einen Algorithmus, um die gesuchte Zahlmöglichst schnell zu ermitteln! Wie viele Versuche benötigen Sie bei Ih-rem Verfahren maximal?

Vorüberlegung:

Um unsere gesuchte Zahl möglichst schnell zu finden, müssen wir zuerst dieWahrscheinlichkeit ermitteln, wo sich diese Zahl im Intervall befinden könnte.Tippen wir z. B. zuerst auf die 1, liegt die Wahrscheinlichkeit bei 99,9 %, dass diein unserem Intervall gesuchte Zahl größer ist; dass sie kleiner ist bei 0 %. Dasheißt, wir müssten noch eventuell 999 mal tippen, wenn wir die Tippreihenfolgeeinfach aufsteigend wählen würden. Wir haben unsere Fehlerwahrscheinlichkeitlediglich um 0,1 % gesenkt.

Wählen wir jedoch die Mitte unseres Bereiches, also 500, liegt unsere Wahr-scheinlichkeit auf der linken Seite bei 49,9 % und auf der rechten bei 50 %. Dasheißt, wir haben unsere maximale Fehlerwahrscheinlichkeit diesmal auf bis zu49,9 % gesenkt !

Regel 1Start

Durch 4 teilbar ?


Ende

Regel 2Durch 100 teilbar ?


Regel 3

Durch 400 teilbar ?



nein

nein

ja

ja

ja

nein


1093

Kapitel 1

Lösu

ngen

Die Wahrscheinlichkeit, dass wir beim ersten Mal sofort die richtige Zahl erraten,liegt sowieso bei allen Taktiken bei 0,1 %.

Bereits jetzt wird es einsichtig, dass wir mit dem Verfahren der Intervallhalbie-rung am schnellsten zum Ziel kommen.

Der Algorithmus:

Problem:

Erraten Sie eine unbekannte Zahl im Intervall 1 � x � 1000!

Anfangsdaten:

geheimzahl = Die zu erratende Zahltipp = Die von uns geratene Zahluntergrenze = Die untere Grenze des Intervallsobergrenze = Die obere Grenze des Intervalls

Anweisungen:

1. Setze tipp = (untergrenze+obergrenze)/2!

2. Falls tipp = geheimzahl, beende das Verfahren!

2.1 Überprüfe, ob tipp < geheimzahl ist!

2.1.1 Falls ja, setze untergrenze = tipp + 1!

2.1.2 Falls nein, setze obergrenze = tipp – 1!

3. Fahre mit Punkt 1 fort.

Erläuterungen:

1. Wir tippen auf die Mitte des Intervalls.

2. Ist die gesuchte Zahl größer als die von uns geratene,

2.1 dann können wir unsere untere Intervallgrenze bis auf die nächsthöhereals die von uns geratene Zahl hochziehen. Wir reduzieren also das mögli-che Intervall, in dem sich unsere Geheimzahl befinden kann, auf dieHälfte.

2.2 Das entsprechende tun wir, falls die gesuchte Zahl kleiner ist, als unser ak-tueller Tipp.

Anzahl der maximal benötigten Versuche:

Um die Anzahl der maximal benötigten Versuche zu bestimmen, müssen wir unsnoch einmal vor Augen führen, dass wir unser Intervall immer wieder ganzzahlighalbieren.


Kapitel 1

1094

Lösu

ngen

Nehmen wir unser Beispiel von 1000 Zahlen, um uns dies deutlich zu machen:

1. Versuch:

2. Versuch:

3. Versuch: usw.

Die Frage ist also, wie oft (x) muss ich die Anzahl meiner Intervallelemente ndurch 2 teilen, um höchstens nur noch eine Möglichkeit zum Auswählen zu ha-ben?

Mathematisch ausgedrückt:

In unserem Falle, also für n=1000, folgt:

Wir benötigen mit unserem Verfahren also höchstens 10 Versuche, um die rich-tige Zahl zu raten.

A 1.5 Formulieren Sie einen Algorithmus, der prüft, ob eine eingegebene Zahleine Primzahl ist oder nicht!

Vorüberlegung:

Eine Primzahl ist eine Zahl , die nur durch sich selbst und durch 1 teilbar ist.Die nahe liegende Lösung wäre, einfach alle Zahlen bis zu unserer eingegebenenPrüfzahl darauf zu testen, ob eine davon ein Teiler unserer Prüfzahl ist. Dann han-delt es sich nicht um eine Primzahl.

Wir können uns den Aufwand an einem Beispiel (Prüfzahl ist die 16) veranschau-lichen:

Bei dieser Methode müssten wir also 14 von 16 Zahlen überprüfen!

1000500

2=

500250

2=

250125

2=

2

12

2

log( )

x

x

n

n

n x

≤

⇔ ≤⇔ ≤

2log(1000)

9,966

10

x

x

x

≥≥=

2≥

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16


1095

Kapitel 1

Lösu

ngen

Wir wollen uns jedoch die Frage stellen, ob wir den Algorithmus effizienter ge-stalten können.

Würden wir z. B. nur bis zu der Hälfte der eingegebenen Zahl testen, dann könn-ten wir uns auch sicher sein, ob es sich um eine Primzahl handelt. Alle Zahlen,die größer als die Hälfte der Prüfzahl und kleiner als sie selbst sind, brauchennicht mehr in Betracht gezogen zu werden, da sie nicht mehr ein ganzzahliger Tei-ler der Prüfzahl sein können.

Wir verdeutlichen uns auch diesen Aufwand:

Hier bräuchten wir noch 6 Zahlen zu überprüfen, wir haben unseren Algorithmusalso ca. doppelt so schnell gemacht.

Wenn wir aber nur bis zu der Quadratwurzel der Prüfzahl testen, dann erhaltenwir dieselbe Sicherheit, ob die Prüfzahl eine Primzahl ist oder nicht.

Dies können wir uns folgendermaßen erklären:

Wenn wir einen Teiler x von einer Zahl z gefunden haben, dann gilt:

wobei y der zweite Teiler ist. Wären nun x und y größer als , dann wäre auch.

Deshalb muss ein Teiler auf jeden Fall kleiner oder gleich sein. Also reicht es,die Zahlen bis zu zu untersuchen.

Wir verdeutlichen uns dies grafisch:

Wir überprüfen bei der Zahl 16 nur noch die Zahlen 2, 3 und 4 als mögliche Tei-ler. In diesem Beispiel gibt es noch eine Zahl, die größer ist als die Quadratwurzelaus 16 und die ein ganzzahliger Teiler von 16 ist: die 8.

Die Überprüfung dieser Zahl haben wir aber durch das Testen der Zahl 2 schonerledigt.

Wie Sie erkennen, müssen wir mit dieser Methode nur noch 3 von 16 Zahlen tes-ten!

Wir haben unser Verfahren also erheblich beschleunigt!

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

z x y= ⋅

z

x y z⋅ >

z

z

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16


Kapitel 1

1096

Lösu

ngen

Der Algorithmus:

Problem:

Überprüfen Sie, ob die eingegebene Zahl eine Primzahl ist!

Anfangsdaten:

pruefzahl = Die zu prüfende Zahltest = Die Zahl, die gerade geprüft wird, ob sie ein Teiler von pruefzahl ist.

Anweisungen:

1. Setze test = 2!

2. Überprüfe, ob das Quadrat von test kleiner oder gleich der pruefzahl ist!Trifft dies nicht zu, dann ist pruefzahl eine Primzahl. Beende das Verfahren!

3. Überprüfe, ob pruefzahl durch test teilbar ist!

3.1 Falls ja, dann ist pruefzahl keine Primzahl!Beende das Verfahren!

3.1.1 Erhöhe test um 1 und fahre mit Punkt 2 fort!

A 1.6 Ihr CD-Ständer hat 100 Fächer, die fortlaufend von 1–100 nummeriertsind. In jedem Fach befindet sich eine CD. Formulieren Sie einen Algo-rithmus, mit dessen Hilfe Sie die CDs alphabetisch nach Interpreten sor-tieren können! Das Verfahren soll dabei auf den beiden folgenden Grund-funktionen basieren:

� vergleiche (n,m)

Vergleiche die Interpreten der CDs in den Fächern n und m! Ergebnis:»richtig« oder »falsch« je nachdem, ob die beiden CDs in der richtigenoder falschen Reihenfolge im Ständer stehen.

� tausche (n,m)

Tausche die CDs in den Fächern n und m!

Vorüberlegung:

Die erste Lösung, die Ihnen hier wahrscheinlich einfallen wird, beruht wohl aufdem Verfahren, wie wir Menschen meistens Dinge sortieren. Wir suchen daskleinste Element und legen es an der ersten Stelle ab. Dann das nächst größereauf der zweiten usw. Diese Lösung ist mit den zur Verfügung stehenden Funktio-nen realisierbar. Wir müssten alle CDs durchlaufen und uns unterwegs merken,welche CD die gerade »kleinste« ist, also der Name welchen Musikers gehört andie erste Stelle. Am Ende angekommen, wären wir uns sicher, dass diejenige CD,die wir gerade als »kleinste« in Erinnerung haben, an die erste Stelle gehört. Dann


1097

Kapitel 1

Lösu

ngen

dasselbe für die zweite Stelle usw. Um die Lösung auf diese Weise zu realisieren,bräuchten wir also ein zusätzliches »Gedächtnis«, eine Variable, in der wir uns diegerade »kleinste« CD merken.

Ich möchte jedoch bei dieser Lösung ein Verfahren vorstellen, bei dem wir dieses»Gedächtnis« nicht brauchen.

Wir durchlaufen die CDs in aufsteigender Richtung und vergleichen immer nurdie nebeneinander stehenden CDs. Wenn diese nicht in der richtigen Reihenfolgestehen, vertauschen wir sie sofort. Nach einem Durchlauf können wir uns dannsicher sein, dass die letzte CD auf dem richtigen Platz steht und brauchen diesenicht mehr zu betrachten.

Wir fangen wieder am Anfang an und fahren solange fort, bis wir nur noch dieerste mit der zweiten CD vergleichen müssen.

Danach sind unsere CDs ganz sicher richtig sortiert!

Wir veranschaulichen uns dies grafisch an einem Beispiel:

Wir nehmen an, die Interpreten hätten als Künstlernamen alle jeweils einen ein-zigen Buchstaben gewählt und ständen in unserem CD-Regal in folgender Reihen-folge:

Wir laufen also die CDs durch, vergleichen und vertauschen gegebenenfalls:

Wie Sie sehen, steht die CD mit dem »größten« Interpreter (Künstlernamen »D«)bereits auf der richtigen Stelle. Beim nächsten Durchlauf werden wir diese CDalso nicht mehr beachten müssen:

D B C A

D B C A

B D C A

B C D A

B C A D

B C A D

B C A D

B A C D


Kapitel 1

1098

Lösu

ngen

Auch hier erkennen Sie, dass die CD »C« schon auf ihrem richtigen Platz steht.Diese brauchen wir beim nächsten Durchlauf nicht mehr zu beachten:

Wie Sie leicht erkennen, sind unsere CDs damit sortiert!

Der Algorithmus:

Problem:

Sortieren Sie Ihre CD-Sammlung alphabetisch!

Anfangswerte:

n = Index der gerade betrachteten CD (erste CD hat den Index 1)a = Gesamtzahl der zu betrachtenden CDs

Anweisungen:

1. Falls a � 2 ist, setze n = 1!Ansonsten beende das Verfahren! Die CDs sind sortiert.

2. Ist n < a, dann fahre mit Punkt 3 fort!Trifft dies nicht zu, erniedrige den Wert von a um 1 und fange wieder vornebei Punkt 1 an!

3. Ist das Ergebnis der Funktion vergleiche(n,n+1) falsch, dann rufe dieFunktion tausche(n,n+1) auf und fahre danach mit Punkt 4 fort. Andern-falls fahre sofort mit Punkt 4 fort.

4. Setze n = n+1 und fahre mit Punkt 2 fort!

B A C D

A B C D


1099

Kapitel 1

Lösu

ngen

Eine bessere Übersicht erhalten wir mithilfe eines Flussdiagramms:

A 1.7 Formulieren Sie einen Algorithmus, mit dessen Hilfe Sie die CDs in IhremCD-Ständer jeweils um ein Fach aufwärts verschieben können! Die dabeiam Ende herausgeschobene CD kommt in das erste Fach. Das Verfahrensoll nur auf der Grundfunktion tausche aus Aufgabe 1.6 beruhen.

Vorüberlegung:

Wir wollen bei diesem Algorithmus von hinten nach vorne arbeiten. Wir fangenbei der letzten CD an und tauschen sie mit der vorletzten, dann die vorletzte mitder vorvorletzten usw.

Dabei wird die letzte CD von hinten nach vorne durchgereicht und landet amEnde auch im ersten Fach, wie es in der Aufgabenstellung gefordert ist.

Verdeutlichen wir uns das Vorgehen grafisch:

4.3.

2.

1.

Start

Eingabe: a

a ≥ 2 ?

a = a - 1

vergleiche(n,n+1)

Ende

n = 1

n < a ?

n = n + 1tausche(n,n+1)

ja

nein

ja

nein

richtigfalsch

A B C D

A B D C

A D B C

D A B C


Kapitel 1

1100

Lösu

ngen

Der Algorithmus:

Problem:

Verschieben Sie die CDs in Ihrem CD-Ständer um ein Fach!Die herausgeschobene CD kommt in das erste Fach!Verwenden Sie dazu nur die Funktion tausche(n,m) aus Aufgabe 1.6!

Anfangsdaten:

n = Index der gerade betrachteten CD (erste CD hat den Index 1)a = Gesamtanzahl der zu betrachtenden CDs

Anweisungen:

1. Setze n = a!

2. Ist n-1 � 1, dann rufe die Funktion tausche(n,n-1) auf!Ansonsten beende das Verfahren!

2.1 Erniedrige den Wert von n um 1 und fahre mit Punkt 2 fort!

Wir verdeutlichen uns auch diesen Algorithmus anhand eines Flussdiagramms:

A 1.8 Formulieren Sie einen Algorithmus, mit dessen Hilfe Sie die Reihenfolgeder CDs in Ihrem CD-Ständer umkehren können! Das Verfahren soll nurauf der Grundfunktion tausche aus Aufgabe 1.6 beruhen.

Vorüberlegung:

Hier werden wir die Möglichkeit verwenden, dass die Funktion tausche(n,m)nicht nur nebeneinander stehende CDs, sondern auch weit entfernte tauschenkann. Wenn wir die Reihenfolge der CDs umkehren sollen, dann muss am Endedie erste CD auf dem letzten Platz landen, die zweite auf dem vorletzten usw. Dieletzte CD gehört dann hingegen auf den ersten Platz, die vorletzte auf den zweitenusw.

2 .1 .

2 .

1 .

S ta rt

E ingabe : a

n = a

n -1≥ 1 ?

n = n - 1tausche(n ,n -1 )

E nde ne in

ja


1101

Kapitel 1

Lösu

ngen

Die naheliegende Lösung, die wir auch hier benutzen werden, ist also, die ersteCD mit der letzten zu tauschen, die zweite mit der vorletzten usw., bis wir in derMitte angekommen sind. Dann haben wir die gesamte Reihenfolge der CDs um-gekehrt. Im Falle einer ungeraden Anzahl von CDs wird die mittlere CD nichtmehr umgetauscht, da sie sich bereits auf dem richtigen Platz befindet.

Grafisch können wir uns das so veranschaulichen:

Der Algorithmus:

Problem:

Kehren Sie die Reihenfolge der CDs in Ihrem CD-Ständer um! Verwenden Siedazu nur die Funktion tausche(n,m) aus Aufgabe 1.6!

Anfangsdaten:

n,m = Indizes der gerade betrachteten CDs (erste CD hat den Index 1)a = Gesamtanzahl der zu betrachtenden CDs

Anweisungen:

1. Setze n = 1 und m = a!

2. Ist n < m, dann rufe die Funktion tausche(n,m) auf!Ansonsten beende das Verfahren!

2.1 Erhöhe den Werte von n um 1, erniedrige den Wert von m um 1 und fahremit Punkt 2 fort!

Das Flussdiagramm:

A B C D

D B C A

D C B A

A B C D E

E B C D A

E D C B A

2.1.

2.

1.

Start

Eingabe: a

m = an = 1

n < m ?

m = m - 1n = n + 1

tausche(n,m)

Ende nein

ja


Kapitel 1

1102

Lösu

ngen

A 1.9 In einem Hochhaus mit 20 Stockwerken fährt ein Aufzug. Im Aufzug sind20 Knöpfe, mit denen man sein Fahrziel wählen kann, und auf jeder Etageist ein Knopf, mit dem man den Aufzug rufen kann. Entwickeln Sie einenAlgorithmus, der den Aufzug so steuert, dass alle Aufzugbenutzer gerechtbedient werden! Sie können dabei annehmen, dass der Aufzug über diefolgenden Befehle zur Fahrtsteuerung bzw. zum Auslesen der Bedienele-mente verfügt:

� fahre(n)

Fahre das Stockwerk n an!

� lade()

Lade oder entlade in dem zuletzt angefahrenen Stockwerk Fahrgäste!

� pruefe(n)

Prüfe, ob Stockwerk n (innen oder außen) als Fahrziel gewählt wurde!Ergebnis: »ja« oder »nein«.

� max()

Liefert die höchste Etage, die aktuell als Fahrziel (innen oder außen) ge-wählt wurde. Ergebnis: Etagennummer.

� min()

Liefert die niedrigste Etage, die aktuell als Fahrziel (innen oder außen)gewählt wurde. Ergebnis: Etagennummer.

� loesche(n)

Löscht Etage n als Fahrziel.

Vorüberlegung:

Unter »gerechte Bedienung der Fahrgäste« könnte man verstehen: »Wer zuerstdrückt, der fährt zuerst«. Vielleicht wäre das eine der gerechtesten Lösungen, abersicherlich nicht die effizienteste. Wir nehmen den Fall an, dass jemand erst ganzoben drückt und danach jemand in der Mitte. Nach der jetzigen Strategie müsstenwir den Fahrstuhl an der Person in der Mitte vorbeifahren lassen, weil die Personganz oben ja zuerst gedrückt hat.

Wesentlich effizienter wäre es aber, die Person in der Mitte unterwegs mitzuneh-men. Dies wollen wir in unserem nachfolgendem Algorithmus auch so handha-ben.

Ich möchte an dieser Stelle den Algorithmus direkt in Form eines Flussdiagrammsvorstellen, da er in der textuellen Darstellung nur sehr schwer nachvollziehbarist:


1103

Kapitel 1

Lösu

ngen

S tart

zie l = max()

ziel > akt ?

fahre(akt+1)akt = akt + 1

pruefe(akt)

loesche(akt)

lade()

ziel = m in()

Richtung ?

fahre(akt-1)akt = akt - 1

zie l < akt ?

Richtung=nach oben

ja

nein

nach oben nach unten

ajaj

nein nein

Richtung=nach oben

akt = 1

Richtung=nach unten


1333

Index

2D-Grafikprogrammierung 701

A

Abstrakte Klasse 746, 844, 927Abstrakter Datentyp 479

Queue 485Stack 480

adjacent_find 1054Adjazenzliste 623Adjazenzmatrix 623Adressbus 137Adresse 137, 254Aggregation 753Aktualparameter 182Algorithmus 23

Algorithmus von Dijkstra 661Algorithmus von Floyd 652Algorithmus von Ford 672Algorithmus von Kruskal 682Algorithmus von Warshall 637

Alignment 459and 703and_eq 703Anweisung

break 59, 297, 300catch-Anweisung 978continue 59, 300do...while 300extern 184for 56, 298goto 300if 53if...else 295return 184, 293struct 444, 497switch 297throw-Anweisung 978try-Anweisung 978union 451, 505while 299

Argument 182Array 156, 279

eindimensionaler Array 156mehrdimensionaler Array 160, 279

Array (Forts.)zweidimensionaler Array 158

Arrays und Zeiger 259ASCII-Zeichensatz 143Assertions 223Assoziativgesetz 104Attribut 744, 759Aufzählungstyp 142

automatische Typisierung 708Ausdruck

arithmetischer Ausdruck 290logischer Ausdruck 290L-Wert 291relationaler Ausdruck 290R-Wert 291Zuweisungs-Ausdruck 290

AusgabeAusgabe in C++ 793Ausgabe in eine Datei 213Ausgabe von ganzen Zahlen 51Ausgabe von Gleitkommazahlen 51Ausgabe von Text 50Bildschirmausgabe 208

Ausgeglichene Bäume 570Ausnahmefallbehandlung 219, 976Aussage 97Aussagenlogik 97Automatische Objekte 943

B

BasisklasseZugriff auf die Basisklasse 937Zugriffsspezifikation private 940Zugriffsspezifikation protected 939Zugriffsspezifikation public 937

Baum 543, 619absteigend sortierter Baum 546aufsteigend sortierter Baum 546ausgeglichener Baum 573AVL-Baum 573, 578Balance 572Baum-Modul 559Binärbaum 545Blätter 545


1334

Index

Baum (Forts.)Inorder-Traversierung 550Knoten 545Level 545Level-Order-Traversierung 557linker Teilbaum 546Nachfolger 544Postorder-Traversierung 552Preorder-Traversierung 549rechter Teilbaum 546Teilbaum 545Tiefe 545Traversierung 547vollständiger Baum 571Wurzel 544

Bedingte Compilierung 306Befehlsausführung

bedingte Befehlsausführung 53wiederholte Befehlsausführung 54

Beidseitige Warteschlangen 1012Beispiel

Algorithmus von Dijkstra 666Algorithmus von Floyd 656Algorithmus von Ford 674, 679Algorithmus von Kruskal 684Algorithmus von Warshall 637Ausnahmefallbehandlung 220AVL-Baum-Modul 575Baum-Modul 559Bingo 811Bit-Editor 152Bubblesort 397Buchstaben zählen 167Damenproblem 226Darlehen 74Dateioperationen 214Division ganzer Zahlen 61Fakultäten 88, 188Geldautomat 340Hamiltonsche Wege 690Hashtabellen-Modul 596Heapsort 416Hofstadter-Funktion 190Inorder-Traversierung 550Insertionsort 402Juwelenraub 335Kombinationen mit Wiederholungen 328Kombinationen ohne Wiederholungen

330

Beispiel (Forts.)Kugelspiel 62, 120Labyrinth 234Legotreppe 81Level-Order-Traversierung 558Listen-Modul 533Matrixdruck 170Menge 800Näherungslösung Travelling Salesman

697Partnervermittlung 871Permutationen 193Permutationen mit Wiederholungen 325Permutationen ohne Wiederholungen

332Postorder-Traversierung 552Preorder-Traversierung 549Queue 486Quicksort 411Schaltung 121Selectionsort 400Shellsort 405Stack 481Summation von Zahlen 66Travelling Salesman Problem 693Traversierung von Graphen 631Variable Anzahl von Argumenten 216Vereinigungssuche 645Würfelspiel 850Zeichensatz 150Zusammenhangskomponenten 645

Bildschirmausgabe 793Binärbaum 545binary_search 1066Binomialkoeffizient 319Bit 136

invertieren 149löschen 149prüfen 149setzen 149

bitand 703Bitfelder 516Bit-Operationen 147bitor 703bitset 1002Bitsets 1002Block 274

Schachtelung von Blöcken 275Variablen in Blöcken 275


1335

Index

bool 703, 710Boolesche Funktion 100break-Anweisung 59, 300Bubblesort 396Byte 136

C

Callback 262calloc 466, 510case-Label 297catch 703, 978class 703, 759, 893Coding-Standards 311Compiler 41Compileschalter 306compl 703const_cast 703const-Deklaration 278continue-Anweisung 59, 300copy 1058copy_backward 1058count 1056count_if 1056Crosscast 932C-Runtime-Library 201

D

Darstellung boolescher Funktionen 106Darstellungssatz für boolesche Funktionen

109Dateioperationen 213

Dateioperationen in C++ 797Datenabstraktion 442Datenbus 137Daten-Member 759, 761, 895Datenstruktur 27, 441

anlegen 445, 498Arrays in Datenstrukturen 501automatische Typisierung 708Bitfelder 516Datenstrukturen und Funktionen 506Datenstrukturen und Zeiger 511direkter Zugriff 503dynamische Datenstrukturen 465, 509indirekter Zugriff 503Initialisierung 445, 498

Datenstruktur (Forts.)Initialisierung zusammengesetzter Daten-

strukturen 500Liste 470, 513lokale Datenstruktur 499Optimierung 457struct 497Typvereinbarungen 515unbenannte Datenstruktur 499union 505Vorwärtsverweise 709Zeiger auf Datenstrukturen 503Zeiger und Datenstrukturen 462zusammengesetzte Datenstruktur 500Zuweisung von Datenstrukturen 502

Datentypchar 141double 142enum 142float 142int 141long 141long double 142short 141signed 141skalarer Datentyp 140, 274unsigned 141void 188

Datum-Funktionen 225De Morgan’sches Gesetz 104Debugger 42Default -Werte 722Default-Konstruktor 780default-Label 297delete 703, 782delete-Operator 782deque 1012Dereferenzierung 254Destruktion 780Destruktor 479, 772, 948Dezimaldarstellung 131Disjunktive Normalform 109Diskriminante 452, 505Distributivgesetz 104Division mit Rest 130do...while-Anweisung 300Downcasts 932Dualdarstellung 131Dynamic Cast 716


1336

Index

dynamic_cast 703, 933Dynamische Arrays 1005Dynamische Datenstrukturen 465, 509Dynamische Objekte 944Dynamische Typüberprüfungen 928

E

Editor 40Einerkomplement 138Einfachvererbung 913Eingabe

Eingabe aus einer Datei 213Eingabe in C++ 796Eingabe von ganzen Zahlen 52Eingabe von Zeichenketten 162Tastatureingabe 208

Eingabeparameter 182equal 1055equal_range 1066Erweiterung abgeleiteter Klassen 835Escape-Sequenz 145, 273Eulerscher Weg 614Exception-Handling 976explicit 703Explizite Instantiierung 956export 703extern 730extern-Anweisung 184

F

Fakultät (n!) 88, 188false 703Fehlerbehandlung 219fill 1061fill_n 1061find 1054find_end 1054find_first_of 1054find_if 1054Flussdiagramm 25Folgen 73for_each 1053for-Anweisung 56, 298Formalparameter 182Format-Anweisungen

Ausgabe 209Eingabe 211

free 466, 510Freispeicherverwaltung 225, 467, 474friend 703Friends 785, 911Function Name Encoding 727Funktion 182, 293

Default-Werte 722Function Name Encoding 727Funktionskörper 184Funktionsprototyp 183, 184, 294, 722globale Funktion 293Implementierung 183Inline-Funktion 724Parameter 186, 293Parametersignatur 727Schnittstelle 184, 293Schnittstellenvariablen 186statische Funktion 294Überladen von Funktionen 726, 836

Funktions-Member 759, 764, 896Funktionsprototyp 184, 722Funktionszeiger 262fwprintf 712fwscanf 712

G

Generalisierung 749generate 1061generate_n 1061Generische Klasse 970Geordnete Paare 1038Geschützte Member 936getwchar 712Gigabyte 140Gleitkommazahlen 44Globale Variablen 199goto-Anweisung 301Graph 616

Adjazenzliste 623Adjazenzmatrix 623Algorithmus von Dijkstra 661Algorithmus von Floyd 652Algorithmus von Ford 672Anfangsknoten einer Kante 616Anfangsknoten eines Weges 617Baum 619bewerteter Graph 620Bewertungsfunktion 620


1337

Index

Graph (Forts.)Endknoten einer Kante 616Endknoten eines Weges 617Existenz von Wegen 629gerichteter Graph 616geschlossener Weg 617Hamiltonscher Weg 689Inzidenzmatrix 625Kante 616Kantentabelle 626Kantenzug 617Knoten 616Kostenfunktion 620Kosten-Wege-Matrix 623Kreis 617kürzeste Wege 649Länge eines Weges 617minimal spannender Baum 682Pfad in einem Graphen 617Schleife 617schleifenfreier Weg 617schwach zusammenhängender Graph 619Spannbaum 682stark zusammenhängender Graph 619symmetrischer Graph 616Travelling Salesman Problem 692Traversierung von Graphen 630ungerichteter Graph 616unzerlegbarer Graph 618Verbindbarkeit von Knoten 618Verfahren von Warshall 637Weg in einem Graphen 617Wegematrix 634Wurzelbaum 620zusammenhängender Graph 619Zusammenhangskomponenten 641

Graphentheorie 613

H

Hamiltonscher Weg 689Hashing 593Hashtabelle 594

Hashfunktion 595Kollision 595Synonymkette 595

Hauptprogramm 43, 182Header-Datei 41, 186, 200, 294, 309Heap 413, 467

Heap-Bedingung 413Heapsort 412Hexadezimaldarstellung 134

I

Idempotenzgesetz 104Identifier 271if-Anweisung 53Implementierung 35, 37Implizite Instantiierung 956Include-Direktive 302includes 1068Indirektzugriff 254Initialisierung

eingelagerter Objekte 957virtueller Basisklassen 962von Basisklassen 960

inline 703Inline-Funktion 724Inorder-Traversierung 550inplace_merge 1066Insertionsort 401Instantiierbare Klassen 746Instantiierung 747, 953

automatische Instantiierung 778, 779dynamische Instantiierung 778, 782Instantiierung abgeleiteter Klassen 833Instantiierung von Arrays 784Instantiierungsregeln 964statische Instantiierung 778, 781von Klassen 777

Instanz 747, 893Inzidenzmatrix 625iter_swap 1058Iteratoren 984

K

Kantentabelle 626Karnaugh-Veitch-Diagramm 113Keyword 271Kilobyte 140Klasse 746, 759, 893

abgeleitete Klasse 913abstrakte Klasse 844Aufbau 759Basisklasse 913Instantiierung 777


1338

Index

Klasse (Forts.)Vererbung 823virtuelle Basisklasse 920Zugriff von außen 904Zugriff von innen 907

Klassenhierarchie 750Klassifizierungsfunktionen 204Kombinationen mit Wiederholungen 320Kombinationen ohne Wiederholungen

318Kombinatorik 315Kombinatorische Algorithmen 324Kommentar 49, 707Kommutativgesetz 104Komplementgesetz 104Konfigurationsmanagement 36Königsberger Brückenproblem 613Konstante 278, 712Konstante Member 899Konstruktor 479, 772, 945

Default-Konstruktor 780Kontrollabstraktion 442Kontrollstrukturen 295Konvertierungsfunktionen 204Kosten-Wege-Matrix 623Kürzeste Wege 649

L

Label 301Laufzeitanalyse

Block 361Fallunterscheidung 357Schleife 355

Laufzeitfunktion 369Laufzeitklassen 375Laufzeitkomplexität 377

exponentielle 381logarithmische 379polynomiale 379

Laufzeitsystem 197Leistungsanalyse 352

Bubblesort 420Heapsort 427Insertionsort 423Quicksort 425Selectionsort 421Shellsort 424

Leistungsmessung 364

Level-Order-Traversierung 557lexicographical_compare 1072LIFO-Prinzip 197Linker 42list 1014Liste 471, 513, 530, 1014

doppelt verkettete Liste 531einfach verkettete Liste 531Listenanfang 530Listenende 530logische Sicht 531Nachfolger 530physikalische Sicht 531Vergleich mit Array 532Vorgänger 530

Listenanker 471Lokale Variablen 199longjmp 977lower_bound 1066L-Wert 291

M

main 43, 293make_heap 1070Makros 305malloc 466, 509map 1045Mathematische Funktionen 201Mathematische Grundfunktionen 369

ceiling 369Exponentialfunktionen 372floor 369Logarithmen 373Potenzfunktionen 371

Matrizenprodukt 635max 1070max_element 1070Megabyte 140Mehrdeutige Vererbung 752, 917Mehrfachvererbung 751, 917Member 759, 894

Daten-Member 761, 895Funktions-Member 764, 896geschützte Member 760, 829, 936öffentliche Member 760private Member 760rein virtuelle Member-Funktion 844, 926statische Member 845, 900


1339

Index

Member (Forts.)virtuelle Member-Funktion 841, 922Zugriff auf Member 903

Mengen 1040merge 1066Message-Passing 755Methode 744, 759min 1070min_element 1070mismatch 1055Modifikation von Zugriffsrechten 941Modularisierung 181multimap 1045multiset 1040mutable 703, 900

N

Nachricht 755Namensraum std 740Namensräume 732namespace 703, 733new 703, 782new-Operator 782next_permutation 1073Nil-Zeiger 471not 703not_eq 703nth_element 1065Null-Zeiger 471

O

Objectfile 42Objekt 744Objektorientierte Programmierung 743

abstrakte Klasse 746Aggregation 753Attribut 744dynamisches Binden 756Generalisierung 749instantiierbare Klasse 746Instantiierung 747Instanz 747Klasse 746Klassenhierarchie 750mehrdeutige Vererbung 752Mehrfachvererbung 751Message-Passing 755

Objektorientierte Programmierung (Forts.)Methode 744Nachricht 755persistente Attribute 745Polymorphismus 756Relation 754Spezialisierung 749transiente Attribute 745Vererbung 748wiederholte Vererbung 752

Oktaldarstellung 133Operator 279, 704, 902

Adressoperator (&) 254Äquivalenz 103arithmetische Operatoren 47, 284Assoziativität 280Auswertungsoperatoren 287Bit-Operatoren 147, 286bitshift links (<<) 149bitshift rechts (>>) 149bitweises entweder oder (^) 149bitweises Komplement (~) 148bitweises oder (|) 148bitweises und (&) 148Cast-Operator 466Class-Member-Zugriff 704Datentyp-Operatoren 288Dekrement-Operator 293delete 704delete-Operator 782Dereferenzierungsoperator (*) 254, 503Globalzugriff 704Implikation 105Indirektzugriff (->) 463, 504, 904Infix-Notation 280Inkrement-Operator 293logische Operatoren 98, 285new 704new-Operator 782nicht-Operator 100nicht-Operator (!) 119oder-Operator 101oder-Operator (||) 119Operatoren auf Klassen 788Operatoren und Ausdrücke 289Pointer to Member 966Pointer to Member (.*) 704Pointer to Member (->*) 704


1340

Index

Operator (Forts.)Postfix-Notation 280Präfix-Notation 280Priorität 102, 280Scope Resolution 725sizeof-Operator 509Stelligkeit 280Strukturzugriff (.) 445, 503Überladen von Operatoren 728, 788und-Operator 101und-Operator (&&) 119Vergleichsoperatoren 49, 285Zugriff (.) 762Zugriffsoperator (.) 904Zugriffsoperatoren 286Zuweisungsoperator (=) 46Zuweisungsoperatoren 289

operator 703or 703or_eq 703

P

pair 1038Parameter 182Parametersignatur 726partial 1065partial_sort 1065partial_sort_copy 1065partition 1064Performance-Analyse 367Permutationen mit Wiederholungen 316Permutationen ohne Wiederholungen

317Pointer 254Pointer to Member 966Polymorphe Klasse 928Polymorphismus 756pop_heap 1069Postorder-Traversierung 552Preorder-Traversierung 549Preprozessor 302Preprozessor-Direktiven 302prev_permutation 1073Prioritätswarteschlangen 1032priority_queue 1032private 703, 894, 904, 936, 940Produkte 87Programm 29

Programmabbruch 223Programmcode 43Programmdateien 308Programmiersprache 29

maschinenorientierte 30spezielle 30universelle 30

Programmrahmen 43Projektplan 36Projektplanung 36protected 703, 894, 904, 936, 939Prozessor 137Prozesssteuerung 226public 703, 894, 936, 937push_heap 1069putwchar 712

Q

Qualitätssicherung 37Quellcode-Datei 41, 310Queue 485, 558

get 486put 486

queue 1030Quicksort 407

R

random_shuffle 1064Realisierung 35realloc 466, 511Referenz 717

Initialisierung von Referenzen 720konstante Referenz 720Referenz auf Variablen 720Referenzen als Rückgabewert 718Referenzen in Funktionsschnittstellen 717

Rein virtuelle Funktion 927Reinterpret Cast 715reinterpret_cast 703Rekursion 188, 196Relationen 754, 1045remove 1062remove_copy 1062remove_copy_if 1062remove_if 1062replace 1059replace_copy 1060


1341

Index

replace_copy_if 1060replace_if 1059return-Anweisung 184, 293Returnwert 182reverse 1064reverse_copy 1064Review 36rotate 1064rotate_copy 1064Rückgabeparameter 182Rückgabewert 182Rücksprungadresse 198Runtime-Library

abort 224abs 202acos 202asctime 225asin 202atan 202atan2 202atexit 224atof 204atoi 204atol 204bsearch 216calloc 225, 466, 510ceil 202clearerr 223clock 226cos 202cosh 202ctime 225difftime 225div 202exit 224exp 202fabs 202fclose 213feof 213ferror 213fflush 213fgetc 213fgetpos 213fgets 213floor 202fmod 202fopen 213fprintf 213fputc 213

Runtime-Library (Forts.)fputs 213fread 213free 225, 466, 510frexp 203fscanf 213fseek 213fsetpos 213ftell 213fwrite 213getc 213getchar 208getenv 226gets 208gmtime 225isalnum 204isalpha 204iscntrl 204isdigit 205isgraph 205islower 205isprint 205ispunct 205isspace 205isupper 205isxdigit 205labs 202ldexp 203ldiv 202localtime 225log 203log10 203longjmp 220malloc 225, 466, 509memchr 225memcmp 225memcpy 225memmove 225memset 225mktime 225modf 203perror 223pow 203printf 208putc 213putchar 208puts 208qsort 216raise 226


1342

Index

Runtime-Library (Forts.)rand 203realloc 225, 466, 511remove 213rename 213rewind 213scanf 206, 208setbuf 213setjmp 220setvbuf 213signal 226sin 203sinh 203sprintf 206sqrt 203srand 203strcat 206strchr 206strcmp 206strcpy 206strcspn 207strerror 223strlen 207strncat 207strncmp 207strncpy 207strpbrk 207strrchr 207strspn 207strstr 207strtod 205strtok 207strtol 205strtoul 205system 226tan 203tanh 203time 225tmofile 214tmpnam 214toascii 205tolower 205toupper 205ungetc 214va_arg 216va_end 216va_start 216vfprintf 219vprintf 219

Runtime-Library (Forts.)vsprintf 219

R-Wert 291

S

Schleife 298Initialisierung 54Inkrement 55Kopf 55Körper 55Test 54

Schlüsselwörter 271, 703and 703and_eq 703bitand 703bitor 703bool 703catch 703class 703compl 703const_cast 703delete 703dynamic_cast 703explicit 703export 703false 703friend 703inline 703mutable 703namespace 703new 703not 703not_eq 703operator 703or 703or_eq 703private 703protected 703public 703reinterpret_cast 703static_cast 703template 703this 703throw 703true 703try 703typeid 703typename 703


1343

Index

Schlüsselwörter (Forts.)using 703virtual 703wchar_t 703xor 703xor_eq 703

Schnittstelle 182, 293search 1054search_n 1054Seiteneffekt 182, 187Selectionsort 398set 1040set_difference 1068set_intersection 1068set_symmetric_difference 1068set_union 1068setjmp 977Shellsort 403sizeof-Operator 509sort 1065sort_heap 1070Sortierverfahren 395, 434

Bubblesort 396Distributionsort 435Heapsort 412Insertionsort 401Leistungsanalyse 418Quicksort 407Selectionsort 398Shellsort 403Vergleich und Bewertung 428

Speicherfunktionen 225Spezialisierung 749Sprunganweisung 300Sprungleisten 296stable_partition 1064stable_sort 1065Stack 197, 480, 553

pop 197, 480push 197, 480

stack 1027Stackpointer 197Stacks 1027static 845Static Cast 714static_cast 703Statische Objekte 943

Statische Variablen 199string 987Stringbearbeitung 206Strings 161, 987struct-Anweisung 444, 497Suchen und Sortieren 216Suffix 272Summen 80swap 1058swap_ranges 1058Symbolische Konstanten 303Systemanalyse 35, 37Systementwurf 35, 37

T

Tastatureingabe 796Tautologie 104Template 970template 703Terabyte 140this 703this-Pointer 799, 910throw 703, 978transform 1053Travelling Salesman Problem 692Traversierung 547true 703try 703, 978type_info 928typeid 703, 928typename 703Typumwandlungen 713Typvereinbarungen 515

U

Überdeckungsanalyse 366Überladen von Funktionen 726Überladen von Operatoren 728union-Anweisung 451, 505unique 1062unique_copy 1062Unterprogramm 182Upcast 931upper_bound 1066using 703, 737


1344

Index

V

Variable Anzahl von Argumenten 216Variablen 45, 274

automatische Variablen 277Definition von Variablen 716Externverweis 200globale statische Variablen 277globale Variablen 187, 199, 277Initialisierung von Variablen 276lokale statische Variablen 277lokale Variablen 199, 276Register-Variablen 277statische Variablen 199

Variablendefinitionen 43Variablendeklarationen 266vector 1005Vereinigungssuche 644Vererbung 748, 823, 913

Einfachvererbung 832, 913mehrdeutige Vererbung 917Mehrfachvererbung 833, 917Modifikation von Zugriffsrechten 941wiederholte Vererbung 918Zugriffsschutz 935Zugriffsspezifikation 936

Verfahren von Warshall 637Verschmelzungsgesetz 104Virtual 703, 842Virtuelle Basisklasse 920Virtuelle Destruktoren 925Virtuelle Funktion 923Virtuelle Member-Funktionen 841vollständiger Baum 571Vorgehensmodell 35

W

Wahrheitstafel 100Warteschlangen 1030wchar_t 703, 711wcscat 712wcscmp 712wcscpy 712

wcslen 712Wegematrix 634while-Anweisung 299Wide Character 711Wiederholte Vererbung 752wprinf 712wscanf 712Wurzel 620Wurzelbaum 620

X

xor 703xor_eq 703

Z

ZahlenDezimalzahlen 131, 272Dualzahlen 131ganze Zahlen 44, 129Gleitkommazahlen 44, 142Hexadezimalzahlen 134, 272Oktalzahlen 133, 272

Zahlendarstellungen 129Zahlenfolge 73

explizite Definition 73induktive Definition 74

Zeichen 273Bildschirm-Steuerzeichen 144druckbares Zeichen 143nicht druckbares Zeichen 143

Zeichenkette 161, 273, 279Länge berechnen 166Terminator 161Zeichenkette kopieren 165Zeichenketten vergleichen 165

Zeichensatz 143Zeiger 254, 463Zeigerarithmetik 257Zeigervariable 254Zeit-Funktionen 225Zusammenhangskomponente 641Zweierkomplement 138


Ulrich Kaiser, Christoph Kecher...Ulrich Kaiser, Christoph Kecher C/C++ 839.book Seite 1 Dienstag,...

Documents

Transcript of Ulrich Kaiser, Christoph Kecher...Ulrich Kaiser, Christoph Kecher C/C++ 839.book Seite 1 Dienstag,...