Kapitel 8
Kapitel 8 Kapitel 8
8 Software-Engineering und DV-Organisation 373 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯-⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ 8 Software-Engineering und DV-Organisation . . .
- Seite 2 und 3: 374 8 Software-Engineering und DV-O
- Seite 4 und 5: 376 8 Software-Engineering und DV-O
- Seite 6 und 7: 378 8 Software-Engineering und DV-O
- Seite 8 und 9: 380 8 Software-Engineering und DV-O
- Seite 10: 382 8 Software-Engineering und DV-O
8 Software-Engineering und DV-Organisation 373<br />
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯-⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯<br />
8 Software-Engineering und DV-Organisation<br />
.<br />
.<br />
.
374 8 Software-Engineering und DV-Organisation<br />
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯-⎯⎯⎯<br />
8.2 Hilfsmittel für den Entwurf von Algorithmen<br />
Ist ein Software-Projekt soweit detailliert beschrieben, dass mit der Programmierung begonnen<br />
werden kann, so stellt sich noch das Problem des Entwurfs und der Darstellung von Algorithmen.<br />
Auch dazu stehen eine Anzahl von Hilfsmitteln zur Verfügung. Einige sollen hier<br />
kurz behandelt werden: Pseudocode, Ablauf- oder Flussdiagramme, Struktogramme und<br />
Entscheidungstabellen. Teilweise kann auch hier auf die in <strong>Kapitel</strong> 8.1 erläuterten Methoden<br />
sowie auf Automaten (siehe <strong>Kapitel</strong> 9.1) zurückgegriffen werden.<br />
8.2.1 Pseudo-Code<br />
Unter einem Pseudo-Code versteht man eine reduzierte und in einer dem Problem angepassten<br />
Weise formalisierte, jedoch der natürlichen Sprache ähnliche Kunstsprache. Algorithmen<br />
lassen sich damit prägnanter und verständlicher formulieren. Um dies zu demonstrieren,<br />
wird der als „binäres Suchen“ bekannte Algorithmus zur Suche eines Eintrages in<br />
einer geordneten Datei zunächst in natürlicher Sprache und anschließend mit Hilfe eines<br />
Pseudo-Codes formuliert:<br />
Beispiel: Binäres Suchen im Klartext und als Pseudo-Code<br />
Gegeben sei eine Datei mit n Elementen, die nach einem Ordnungskriterium (z.B. lexikographisch,<br />
oder bei numerischen Werten, der Größe nach) geordnet sind. Für ein bestimmtes,<br />
vorgegebenes Element x ist nun der die Position von x in der Datei kennzeichnende Index zu<br />
ermitteln. Dazu wird die Datei in eine untere und eine obere Hälfte unterteilt. Nun wird durch<br />
Vergleich von x mit demjenigen Element, das gerade die Grenze zwischen den beiden Hälfte<br />
bildet, festgestellt, ob es mit diesem Element übereinstimmt, oder ob es in der oberen oder in<br />
der unteren Hälfte liegen müsste, sofern es überhaupt in der Datei enthalten ist. Man halbiert<br />
nun auf diese Art den Suchbereich, in dem x jeweils vermutet wird, immer weiter, bis entweder<br />
x gefunden wurde, oder bis der Suchbereich kein Element mehr enthält. In diesem Fall<br />
ist x in der untersuchten Datei nicht enthalten.<br />
Diese Beschreibung des Algorithmus in natürlicher Sprache ist nicht so weit gehend formalisiert,<br />
dass eine Übertragung in ein Programm ohne weiteres möglich wäre. Insbesondere<br />
wäre eine automatische Programm-Generierung mit Hilfe eines Software-Werkzeugs derzeit<br />
noch undurchführbar. Unter Verwendung eines einfachen Pseudo-Codes lässt sich der Algorithmus<br />
jedoch in eine kompakte und dennoch leicht lesbare Form bringen:<br />
SETZE untergr auf 1<br />
SETZE obergr auf n<br />
SOLANGE untergr
8 Software-Engineering und DV-Organisation 375<br />
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯-⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯<br />
keine Programmiersprache beherrscht, diesen in Pseudo-Code formulierten Algorithmus<br />
verstehen können. Die Blockstruktur wird – wie allgemein üblich – augenfällig durch Einrücken<br />
kenntlich gemacht.<br />
Als weitere Abstraktionen von der natürlichen Sprache sind in dem obigen Pseudo-Code<br />
noch mathematische Formeln sowie kursiv gedruckte, abkürzende Namen eingeführt worden.<br />
Es sind dies untergr für die untere Grenze des betrachteten Intervalls, obergr für die<br />
obere Grenze, n für die Anzahl der Elemente der Datei, x für das gesuchte Element und der<br />
Index k, der die Elemente durchnummeriert.<br />
8.2.2 Ablauf- oder Flussdiagramme<br />
Mit Hilfe von Ablaufdiagrammen oder Flussdiagrammen, deren Symbole beispielsweise in<br />
DIN 66001 und DIN 66262 normiert sind, lassen sich dynamische Vorgänge auf übersichtliche<br />
Weise grafisch darstellen. Die dazu verwendeten Symbole sind direkt aus der erweiterten<br />
D-Struktur (siehe <strong>Kapitel</strong> 6.1.3) abgeleitet:<br />
Grenzstelle (z.B. Start oder Modul-Ende)<br />
Verbindungsstelle<br />
Eingabe oder Ausgabe<br />
Anweisung, Aktion<br />
Unterprogrammaufruf<br />
ja<br />
Bedingung<br />
nein<br />
Verzweigung<br />
Bedingung<br />
Mehrfachverzweigung (Auswahl) mit gemeinsamer<br />
Bedingung und Auswahlbedingungen A i<br />
A 1<br />
A 2<br />
A 3<br />
. . . A n<br />
Abbildung 8.2.1: Zusammenstellung der wichtigsten in Flussdiagrammen verwendeten Symbole.
376 8 Software-Engineering und DV-Organisation<br />
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯-⎯⎯⎯<br />
Damit lassen sich alle benötigten Programmkonstrukte, einschließlich Schleifen und Rekursionen,<br />
darstellen.<br />
Beispiel: Binäres Suchen als Flussdiagramm<br />
Als Anwendungsbeispiel wird nun der oben in Form von Pseudo-Code eingeführte Algorithmus<br />
„binäres Suchen“ nach einem Element in einem Array a in ein Flussdiagramm übertragen.<br />
START<br />
Hauptprogramm Suchen<br />
x einlesen<br />
pos=Bin_Such(x)<br />
ja<br />
pos < 0 <br />
nein<br />
„nicht gefunden“<br />
„gefunden“<br />
Gib aus: pos<br />
ENDE<br />
START<br />
Funktion Bin_Such(x)<br />
ug=1; og=n;<br />
nein<br />
og >= ug <br />
ja<br />
Rücksprung<br />
Rückgabewert = -1<br />
ja<br />
k=ug+(og-ug)/2<br />
nein<br />
xa[k]<br />
ja<br />
og=k-1<br />
Rücksprung<br />
Rückgabewert = k<br />
ug=k+1<br />
Abbildung 8.2.2: Flussdiagramm des Programms "binäres Suchen".
8 Software-Engineering und DV-Organisation 377<br />
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯-⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯<br />
8.2.3 Struktogramme nach Nassi-Shneiderman<br />
Neben den Flussdiagrammen sind auch Struktogramme oder Nassi-Shneiderman-<br />
Diagramme gebräuchlich (siehe DIN 66261). Oft erlauben Struktogramme eine übersichtlichere<br />
Darstellung als Flussdiagramme. Dies ist auf den Wegfall der vielen Pfeile und Linien<br />
zurückzuführen, die in längeren Flussdiagrammen oft verwirrend wirken. Die folgende Abbildung<br />
zeigt die wichtigsten Struktogramm-Symbole.<br />
Anweisung, Block<br />
parallele Blöcke<br />
Block1 Block2 Block3<br />
Alternativanweisung<br />
Bedingung<br />
ja<br />
nein<br />
ja-Block nein-Block<br />
Unterprogramm-Aufruf<br />
Auswahlanweisung<br />
Bedingung<br />
1.<br />
2.<br />
3.<br />
Block1 Block2 Block3 Sonst<br />
Blocksequenz<br />
Block 1<br />
Block 2<br />
Block 3<br />
abweisende<br />
Wiederholungsanweisung<br />
Block<br />
Bedingung<br />
nicht abweisende<br />
Wiederholungsanweisung<br />
Bedingung<br />
Block<br />
Abbildung 8.2.3: Zusammenstellung der wichtigsten in Struktogrammen verwendeten Symbole.<br />
Beispiel: Binäres Suchen als Struktogramm<br />
Der in <strong>Kapitel</strong> 8.2.2 als Flussdiagramm beschriebene Suchalgorithmus zum Auffinden der<br />
Position pos eines Elementes x in einem Array a hat als Struktogramm folgende Form:<br />
PROGRAMM Suchen<br />
Lies x<br />
pos = Bin_Such(x)<br />
pos < 0 <br />
ja<br />
nein<br />
„nicht „gefunden“<br />
gefunden“<br />
gib aus: pos<br />
Abbildung 8.2.4:<br />
Struktogramm des Programms "binäres Suchen".<br />
ja<br />
og=k-1<br />
FUNCTION Bin_Such(x)<br />
Vorbesetzung: ug=1, og=n<br />
Solange og>=ug<br />
ja<br />
k=ug+(og-ug)/2<br />
xa[k] <br />
nein<br />
Rücksprung<br />
Rückgabewert=k<br />
Rücksprung, Rückgabewert = -1
378 8 Software-Engineering und DV-Organisation<br />
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯-⎯⎯⎯<br />
Ausgehend von einem Ablaufdiagramm oder einem Struktogramm ist nun die Aufgabe des<br />
Umsetzens des Algorithmus in ein Programm wesentlich einfacher und zudem teilweise<br />
durch CASE-Tools auch automatisierbar, als dies ohne solche Hilfsmittel möglich wäre. Dies<br />
gilt umso mehr, wenn mehrere Personen an demselben Projekt arbeiten. Im folgenden Beispiel<br />
ist das binäre Suchen als C-Programm formuliert. Für Details zur Programmierung in C<br />
sei auf <strong>Kapitel</strong> 6.3 verwiesen.<br />
Beispiel: Binäres Suchen als C-Programm<br />
Im folgenden Beispiel wird der oben erläuterte Algorithmus „binäres Suchen“ dazu verwendet,<br />
eine global als Array deklarierte Kundendatei nach einer einzugebenden Postleitzahl zu<br />
durchsuchen. Das resultierende C-Programm, zu dem als wichtiger Bestandteil auch die<br />
global definierte Datenstruktur kunden_type und das Array kundendatei gehören, kann<br />
beispielsweise so aussehen:<br />
#define MAX 1000<br />
// Maximale Anzahl der Kunden<br />
struct kunden_typ { int kundennr;<br />
struct name_typ { char anrede[20];<br />
char vorname[20];<br />
char famname[20];<br />
} name;<br />
struct adr_typ { char strasse[30];<br />
int hausnr;<br />
int plz;<br />
char ort[30];<br />
} adr;<br />
char telnr[20];<br />
};<br />
struct kunden_typ kundendatei[MAX];<br />
// Kundendatei<br />
int Bin_Such(int x)<br />
// Funktion binäres Suchen<br />
{<br />
int ug=0, og=MAX-1, k;<br />
while(og>=ug) {<br />
k=ug+(og-ug)/2;<br />
if(xkundendatei[k].adr.plz) ug=k+1;<br />
else return k;<br />
// gefunden an Position k<br />
}<br />
}<br />
return -1;<br />
// nicht gefunden<br />
}<br />
int main()<br />
// Hauptprogramm<br />
{<br />
int plz, pos;<br />
printf("\nZu suchende Postleitzahl = ");<br />
scanf("%d",&plz);<br />
// Postleitzahl einlesen<br />
pos=Bin_Such(plz);<br />
// Postleitzahl suchen<br />
if(pos
8 Software-Engineering und DV-Organisation 379<br />
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯-⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯<br />
8.2.4 Entscheidungstabellen<br />
Schließlich soll noch ein insbesondere bei der übersichtlichen Darstellung komplizierter logischer<br />
Verknüpfungen und bei Testverfahren sehr nützliches Hilfsmittel vorgestellt werden,<br />
nämlich Entscheidungstabellen (Decision Tables).<br />
Bedingungstabelle<br />
Eine Entscheidungstabelle besteht aus zwei Komponenten: der Bedingungstabelle und der<br />
Aktionstabelle. In die Bedingungstabelle (auch Zustandstabelle genannt), die in der linken<br />
Spalte eine Kurzbeschreibung der Bedingungen enthält, werden alle relevanten Kombinationen<br />
der Erfüllung oder Nichterfüllung eingetragen. Man erhält damit ein Muster aus den möglichen<br />
Einträgen „ja“, (Bedingung erfüllt) und „nein“ (Bedingung nicht erfüllt). Sind alle<br />
Ja/Nein-Kombinationen auch wirklich in die Tabelle eingetragen, so ergeben sich für eine<br />
vollständige Entscheidungstabelle mit n Bedingungen 2 n Spalten (Entscheidungen). Bei einer<br />
größeren Zahl von Bedingungen wird also die Anzahl der Entscheidungen sehr rasch unübersichtlich<br />
groß. Als Ausweg kann man das Problem in mehrere kleinere Teilprobleme<br />
unterteilen und in eine Entscheidungstabelle Verweise auf andere Entscheidungstabellen<br />
aufnehmen. Die Anzahl der Einträge reduziert sich in den meisten Fällen auch dadurch, dass<br />
die Erfüllung oder Nichterfüllung einer bestimmten Bedingung für die folgende Aktion ohne<br />
Belang ist. In diesem Fall kann man zwei Spalten zusammenfassen und an Stelle von „ja“<br />
oder „nein“ ein Zeichen mit der Bedeutung „egal“ eintragen, beispielsweise einen Strich. Dadurch<br />
wird aus einer vollständigen Entscheidungstabelle eine unvollständige Entscheidungstabelle,<br />
die gleichwohl denselben Sachverhalt beschreibt.<br />
Aktionstabelle<br />
Unter der Bedingungstabelle wird die Aktionstabelle angeordnet, die in der linken Spalte eine<br />
Kurzbeschreibung der möglichen Aktionen (Funktionen) enthält. In den zu den Spalten der<br />
Bedingungstabelle korrespondierenden Spalten wird für jede Kombination von Erfüllung bzw.<br />
Nichterfüllung der Bedingungen die Folge der resultierenden Aktionen gekennzeichnet, und<br />
zwar nach Möglichkeit in der Reihenfolge ihrer Ausführung. Eine Entscheidung kann zu einer<br />
beliebigen Zahl von Aktionen führen und eine Aktion kann zu mehreren Entscheidungen gehören.<br />
Auch die Feststellung, dass zu einer bestimmten Entscheidung überhaupt keine Aktion<br />
ausgeführt zu werden braucht, ist in diesem Sinne eine Aktion, die notiert werden muss.<br />
Bedingungen Erfüllung Bedingungstabelle<br />
B1<br />
B2<br />
Eintrag: ja (j)<br />
nein (n)<br />
.<br />
egal (-)<br />
.<br />
.<br />
Aktionen<br />
F1<br />
Ausführungsfolge Aktionstabelle<br />
F2<br />
.<br />
.<br />
Funktion ausführen: (*)<br />
.<br />
Abbildung 8.2.6: Die Elemente von Entscheidungstabellen: Bedingungstabelle und Aktionstabelle.
380 8 Software-Engineering und DV-Organisation<br />
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯-⎯⎯⎯<br />
Ein Nachteil von Entscheidungstabellen ist ihr statischer Charakter. Dynamische Strukturen,<br />
die über eine einfache Iteration hinausgehen, können nicht ausgedrückt werden.<br />
Vollständige Entscheidungstabellen<br />
Beim Erstellen einer Entscheidungstabelle mit n Bedingungen beginnt man am besten mit<br />
dem Anlegen einer vollständigen Entscheidungstabelle mit 2 n Entscheidungen. Dabei kann<br />
es geschehen, dass die Tabelle technisch unmögliche Kombinationen von Bedingungen enthält.<br />
Bei dem nachstehend beschriebenen Vereinfachungsschritt lösen sich diese Unmöglichkeiten<br />
jedoch auf. Gelegentlich wird man auch Bedingungen finden, für die in der Spezifikation<br />
gar keine zugehörige Aktion vorgesehen ist oder dass Widersprüchlichkeiten auftauchen.<br />
Das Erstellen einer vollständigen Entscheidungstabelle ist damit auch ein gutes Hilfsmittel<br />
für die Konsistenz- und Vollständigkeitskontrolle des zu Grunde liegenden Entwurfs.<br />
Vereinfachen von Entscheidungstabellen<br />
Im nächsten Schritt kann man die Vereinfachung bzw. Reduzierung der Entscheidungstabelle<br />
in Angriff nehmen. Trifft man zwei Spalten an, welche dieselben Aktionen enthalten und<br />
bei denen sich die Bedingungen lediglich in einer Position unterscheiden, so ist die Bedingung<br />
an dieser Stelle offenbar nicht relevant. In diesem Fall ersetzt man die Ja/Nein-Einträge<br />
an der betreffenden Position durch einen Strich. Da diese Modifikation sowohl in der Spalte<br />
durchgeführt wurde, in der an der fraglichen Position „ja“ eingetragen war als auch in der<br />
Spalte, in der „nein“ eingetragen war, hat man nun zwei identische Spalten, wovon eine entfernt<br />
werden kann. Auf diese Weise verfährt man, bis keine Vereinfachung mehr möglich ist.<br />
Mit diesem Vereinfachungsverfahren kann man Entscheidungstabellen auf Vollständigkeit<br />
prüfen. Man zählt dazu alle Spalten, die keinen Strich als Eintrag haben einfach und alle<br />
Spalten mit Strichen 2 k -fach, wobei k die Anzahl der Striche in der Spalte ist. Die Summe<br />
muss bei n Bedingungen 2 n ergeben. Anhand eines Beispiels soll nun das Erstellen und Vereinfachen<br />
einer Entscheidungstabelle vorgeführt werden.<br />
Beispiel<br />
Die Spezifikation des Problems laute folgendermaßen:<br />
Ein Händler führt Artikel, die in Warengruppen kategorisiert sind. Bestellt ein Kunde pro Jahr Waren<br />
im Wert von weniger als 5 000,- €, so erhält er keinen Rabatt. Liegt der Bestellwert zwischen 5 000,-<br />
und 10 000,- €, so erhält er im Falle der Warengruppen 1, 3 oder 6 8% Rabatt, im Falle der Warengruppen<br />
2, 4 oder 5 10% Rabatt und im Falle aller anderen Warengruppen 5% Rabatt. Liegt der Bestellwert<br />
über 10 000,- €, so erhält der Kunde im Falle der Warengruppen 1, 3 oder 6 15% Rabatt, im<br />
Falle der Warengruppen 2, 4 oder 5 20% Rabatt und im Falle aller anderen Warengruppen 10% Rabatt.<br />
Der Kunde erhält außerdem ein Werbegeschenk zum Jahreswechsel, wenn er einen Rabatt von<br />
mindestens 10% erhalten hat.<br />
Zunächst wird aus diesen Angaben eine vollständige Entscheidungstabelle konstruiert. Man<br />
erkennt, dass vier Bedingungen ausreichen, um alle Entscheidungen zu erfassen, nämlich<br />
Artikelnummer:1,3,6, Artikelnummer:2,4,5, Bestellwert >5000 € und Bestellwert >10000 €. Die<br />
vollständige Entscheidungstabelle muss also der Anzahl der möglichen Entscheidungen entsprechend<br />
2 4 =16 Spalten erhalten. Die Bedingungstabelle der vollständigen Entscheidungstabelle<br />
ist damit festgelegt. Sie enthält allerdings einige Kombinationen, die in der Praxis<br />
nicht auftreten können. Dies betrifft beispielsweise alle Spalten, in denen sowohl für die Bedingung<br />
Warengruppe: 1,3,6 als auch für die Bedingung Warengruppe: 2,4,5 „j“ eingetragen ist.<br />
In der Aktionstabelle wird in den betreffenden Spalten kein Eintrag vorgenommen. Bei der<br />
anschließenden Reduzierung werden dann diese Spalten eliminiert. Die folgende Abbildung<br />
zeigt das Ergebnis.
8 Software-Engineering und DV-Organisation 381<br />
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯-⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯<br />
Bedingungstabelle<br />
Warengruppe: 1,3,6 j j j j j j j j n n n n n n n n<br />
Warengruppe: 2,4,5 j j j j n n n n j j j j n n n n<br />
Bestellwert > 5000 € j j n n j j n n j j n n j j n n<br />
Bestellwert > 10000 € j n j n j n j n j n j n j n j n<br />
Funktionstabelle<br />
Kein Rabatt x x x<br />
Rabatt 5%<br />
x<br />
Rabatt 8%<br />
x<br />
Rabatt 10% x x<br />
Rabatt 15%<br />
x<br />
Rabatt 20%<br />
x<br />
Weihnachtsgeschenk x x x x<br />
Abbildung 8.2.7: Beispiel für die im Text beschriebene Entscheidungstabelle.<br />
Eine Analyse dieser vollständigen Entscheidungstabelle zeigt, dass man durch Zusammenfassen<br />
die Anzahl der Spalten von 16 auf 7 reduzieren kann:<br />
Bedingungstabelle<br />
Warengruppe: 1,3,6 j j n n n n -<br />
Warengruppe: 2,4,5 n n j j n n -<br />
Bestellwert > 5000 € j j j j j j n<br />
Bestellwert > 10000 € j n j n j n -<br />
Funktionstabelle<br />
Kein Rabatt<br />
Rabatt 5%<br />
Rabatt 8%<br />
x<br />
Rabatt 10% x x<br />
Rabatt 15%<br />
x<br />
Rabatt 20%<br />
x<br />
Weihnachtsgeschenk<br />
x x x x<br />
Abbildung 8.2.8:<br />
x<br />
x<br />
Die in Abbildung 8.2.7 angegebene Entscheidungstabelle wurde durch Zusammenfassen von Spalten<br />
reduziert und dadurch stark vereinfacht.<br />
Abbildung 8.2.9 zeigt zum Vergleich noch eine Darstellung der in Abbildung 8.2.8 angegebenen<br />
reduzierten Entscheidungstabelle in Form eines Flussdiagramms.
382 8 Software-Engineering und DV-Organisation<br />
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯-⎯⎯⎯<br />
START<br />
j<br />
A=1,3,6<br />
n<br />
j<br />
A=2,4,5<br />
n<br />
j<br />
W>5000<br />
n<br />
R=0<br />
j<br />
W>10000<br />
n<br />
R=5<br />
n<br />
W>5000<br />
j<br />
R=10<br />
n<br />
W>10000<br />
j<br />
R=20<br />
Geschenk<br />
R=10<br />
R=0<br />
n<br />
W>5000<br />
j<br />
n<br />
W>10000<br />
j<br />
R=15<br />
R=8<br />
R=0<br />
Abbildung 8.2.9:<br />
Darstellung der in Abbildung 8.2.8 angegebenen Entscheidungstabelle als Flussdiagramm.<br />
STOP