Weiteres Programm
Download
1 / 27

Weiteres Programm - PowerPoint PPT Presentation


  • 52 Views
  • Uploaded on

Weiteres Programm. Studium des Breitendurchlaufs. Hierzu zunächst Studium von Warteschlangen zuerst einfache Warteschlangen aus ganzen Zahlen daraus Abstrakter Datentyp Warteschlange Anpassung für Baumknoten. 6. 23. 4. 7. 18. 26.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Weiteres Programm' - kane


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Weiteres programm

Weiteres Programm

Studium des Breitendurchlaufs

  • Hierzu

  • zunächst Studium von Warteschlangen

    • zuerst einfache Warteschlangen aus ganzen Zahlen

    • daraus Abstrakter Datentyp Warteschlange

  • Anpassung fürBaumknoten


Weiteres programm

6

23

4

7

18

26

Strategie bei den drei behandelten Durchlaufarten durchbinäre Suchbäume heißt Tiefensuche (es wird zunächst in die

Tiefe und nicht in die Breite gegangen).

Alternative: Breitensuche - trage den Baum schichtenweise ab.

Beispiel:

17

17 # 6 # 23 # 4 # 7 # 18 # 26

Implementation?


Weiteres programm

Idee:

verwalte die Knoten in einer Warteschlange.

  • ein Knoten wird gedruckt

  • seine Söhne werden in die Warteschlange eingefügt

bis die Warteschlange leer ist

Initialisierung der Warteschlange: Wurzel


Weiteres programm

Beispiel:

17

6

23

4

7

18

26


Weiteres programm

Realisierung?

Wir machen einen Ausflug in das Gebiet der Warteschlangen.

  • Eine Warteschlange arbeitet so:

  • Einfügen von Elementen am Ende

  • Entfernen von Elementen am Anfang

Vereinfachende Annahme für diese einführende

Diskussion: Elemente sind ganze Zahlen.


Weiteres programm

Berücksichtigt werden muß:

  • ausgezeichnete Elemente Anfang (Kopf) und Ende (Fuß)

  • Liste der Elemente (möchte mich nicht am Anfang auf eine feste Anzahl von Elementen festlegen; sonst: Feld möglich)

  • Operationen:

    • Einfügen am Ende

    • Entfernen am Anfang

    • Initialisierung

Wunsch:

möchte Daten und Operationen gern zusammen

betrachten können.


Weiteres programm

die bekannte

Listendeklaration.

struct IntListe {

int Element;

IntListe * weiter;

};

Aber weiter: Kopf, Fuß und Operationen auf der

Warteschlange?

Idee:

deklariere entsprechende struct.


Weiteres programm

struct Warteschlange {

Kopf

Fuss

Warteschlange

};

DieListe

IntListe * DieListe;

IntListe * Kopf, *Fuss;

Einfuegen(int)

IntListe * Einfuegen(int);

Entfernen()

IntListe * Entfernen();

Init()

IntListe * Init();

DerKopf()

int DerKopf();

ListenDruck(...)

void ListenDruck(ofstream *);


Weiteres programm

Damit wird die Signatur der Operationen mit den Daten

für die Operationen gemeinsam deklariert.

Vorteil:

  • alle Eigenschaften eines Datentyps (hier: Warteschlange) sind zusammengefaßt.

  • die wesentlichen Operationen, die zu einem Datentyp gehören, werden mit dem Datentypen vereinbart, d.h.

  • Lokalität der Änderungen

  • Übersichtlichkeit

  • Verständlichkeit


Weiteres programm

Problem: wir kennen die Signaturen der Operationen.

Was ist mit dem Code?

Der wird getrennt von der struct-Definition vereinbart.

  • (Analogie:

  • Angabe der Signatur der benutzten Funktionen in einer Funktion,

  • davon getrennte Angabe des Code)


Weiteres programm

Name des Typs

“das zum Typ

Warteschlange

gehörende Init”

Typ des Rückgabewerts

IntListe * Warteschlange::Init() {

Kopf = Fuss = NULL;

return Kopf;

};

Name der Funktion


Weiteres programm

IntListe * Warteschlange::Init() {

DieListe = Kopf = Fuss = NULL;

return DieListe;

};

Beachte:

  • die in der struct-Definition definierten Namen (Kopf, Fuss) sind hier sichtbar.

  • der Name der struct muß angegeben werden, um die Zuordnung zu ermöglichen (Init kann ja auch bei anderen Typen vorkommen).


Weiteres programm

Konvention

Weitere Beispiele

int Warteschlange::DerKopf() {

return (DieListe == NULL ?

-1 : DieListe->Element);

};

void Warteschlange::ListenDruck(ofstream *aus) {

IntListe * Laeufer = Kopf;

while (Laeufer != NULL) {

*aus << Laeufer->Element << endl;

Laeufer = Laeufer->weiter;

}

};


Weiteres programm

IntListe * Warteschlange::Entfernen() {

if (Kopf == NULL){

DieListe = Kopf;

return NULL;

else {

if (Kopf == Fuss) {

Kopf = Fuss = NULL;

}

else {

Kopf = Kopf->weiter;

}

DieListe = Kopf

return DieListe;

}

};


Weiteres programm

IntListe * Warteschlange::Einfuegen(int i) {

IntListe *K = new IntListe;

K->Element = i;

K->weiter = NULL;

if (DieListe == NULL){

Kopf = K;

Kopf->weiter = Fuss;

}

else if (Fuss == NULL){

Kopf->weiter = K;

Fuss = K;

}

else {

Fuss->weiter = K;

Fuss = K;

}

DieListe = Fuss;

return DieListe;

};

der Code

müßte bekannt

sein


Weiteres programm

Deklaration der Warteschlange

Zugriff über Qualifikation

void main() {

ofstream *out = new ofstream("aus.aus");

Warteschlange W;

W.Init();

for (int i=1; i < 10; i++) W.Einfuegen(i);

W.ListenDruck(out); W.Einfuegen(117);

*out << "\nNach Einfuegen von 117: " << endl;

W.ListenDruck(out);

*out << "\nKopf: " << W.DerKopf() << endl;

W.Entfernen();

*out << "\nNach Entfernen des ersten Elements: ";

W.ListenDruck(out);

*out << "\nKopf: " << W.DerKopf() << endl;

}


Weiteres programm

Ausgabe:

1 # 2 # 3 # 4 # 5 # 6 # 7 # 8 # 9 #

Nach Einfuegen von 117:

1 # 2 # 3 # 4 # 5 # 6 # 7 # 8 # 9 # 117 #

Kopf: 1

Nach Entfernen des ersten Elements:

2 # 3 # 4 # 5 # 6 # 7 # 8 # 9 # 117 #

Kopf: 2

Programm: prog-21.cpp


Weiteres programm

Beobachtung:

Eigentlich werden die Interna (Kopf, Fuss, DieListe

etc) überhaupt nicht benötigt.

  • Die Interna könnten/sollten privat, d.h. verborgen bleiben.

  • Zugriff von außen nur über die entsprechenden Operationen

  • Warteschlange als eine Art Datenkapsel mit

    • internen Zustand (Kopf, Fuss, DieListe)

    • Zugriffsoperationen (Einfuegen etc.)

    • Zustand von außen nicht änderbar

Abstrakter

Daten-

typ


Weiteres programm

DieListe

Kopf

Fuss

Einfuegen(int)

privat

Entfernen()

öffentlich

Init()

DerKopf()

ListenDruck(...)


Weiteres programm

neu

beachte:

void

Führt zu folgender Deklaration:

struct Warteschlange {

private:

IntListe * DieListe;

IntListe * Kopf, * Fuss;

public:

void Einfuegen(int);

void Entfernen();

void Init();

int DerKopf();

void ListenDruck(ofstream *);

};


Weiteres programm

hierbei:

  • public deutet an, daß auf die darauf folgenden Namen von außen (durch Qualifikation) zugegriffen werden darf.

  • private deutet an, daß die darauf folgenden Namen vor dem Zugriff geschützt sind

Beispiel: Warteschlange W seideklariert.

Illegal:

W.Kopf

W.DieListe

W.Fuss

Legal z.B.:

W.Init()

W.Einfuegen(45)

W.DerKopf()


Weiteres programm

Änderungen:

Typ der

Rückgabe

ist void;

return

eliminiert

void Warteschlange::Einfuegen(int i) {

IntListe *K = new IntListe;

K->Element = i;

K->weiter = NULL;

if (DieListe == NULL){

Kopf = K;

Kopf->weiter = Fuss;

}

else if (Fuss == NULL){

Kopf->weiter = K;

Fuss = K;

}

else {

Fuss->weiter = K;

Fuss = K;

}

DieListe = Kopf;

};


Weiteres programm

Programm: prog-21a.cpp

Allgemeine Anmerkung: Warteschlange wird ein abstrakter

Datentyp (ADT) genannt.

  • ADTs sind charakterisiert durch

    • Offenlegen der Schnittstellen (Signaturen)

    • Verbergen der Implementation (d.h. Zugriff nur über wohldefinierte Operationen)

Wichtige Konstruktion in der Softwaretechnik, insb. im

objektorientierten Entwurf.

Wesentliches Thema

für das

zweite Semester


Weiteres programm

Zurück zur Breitensuche.

Strategie:

  • Verwendung einer Warteschlange Q, die aus

  • Knoten des Baums besteht

  • Füge zunächst den Wurzelknoten in Q ein.

  • der Kopf K von Q wird gedruckt.

  • nach dem Druck geschieht folgendes:

    • ist K.LSohn != NULL, so wird dieser Knoten in Q eingefügt,

    • ist K.RSohn != NULL, so wird dieser Knoten in Q eingefügt,

  • das geschieht solange, bis Q leer ist


Weiteres programm

struct BinBaum {

char text[maxLen];

int zaehler;

BinBaum * LSohn, *RSohn;

};

struct BaumListe {

BinBaum * Element;

BaumListe * weiter;

};

struct Warteschlange {

private:

BaumListe * DieListe;

BaumListe * Kopf, * Fuss;

public:

void Einfuegen(BinBaum *);

void Entfernen();

void Init();

int IstLeer();

BinBaum * DerKopf();

};

Änderung im

Typ des Listen-

elements

Anpassung der Datentypen:


Weiteres programm

zentrale Prozedur:

void BreitenSuche(BinBaum *K, ofstream *aus) {

void KnotenDruck(BinBaum *, ofstream *);

Warteschlange W;

W.Init();

W.Einfuegen(K);

while (!W.IstLeer()) {

BinBaum *L = W.DerKopf();

W.Entfernen();

W.Einfuegen(L->LSohn);

W.Einfuegen(L->RSohn);

KnotenDruck(L, aus);

}

}

Programm: prog-22.cc


Weiteres programm

Herr von Ribbeck auf Ribbeck im Havelland,

Ein Birnbaum in seinem Garten stand,

Und kam die goldene Herbsteszeit

Und die Birnen leuchteten weit und breit,

Da stopfte, wenn's Mittag vom Turme scholl,

Der von Ribbeck sich beide Taschen voll,

Und kam in Pantinen ein Junge daher,

So rief er: »Junge, wiste 'ne Beer?«

Und kam ein Mädel, so rief er: »Lütt Dirn,

Kumm man röwer, ick hebb 'ne Birn.«

So ging es viel Jahre, bis lobesam

Der von Ribbeck auf Ribbeck zu sterben kam.

Er fühlte sein Ende. 's war Herbsteszeit,

Wieder lachten die Birnen weit und breit;

Da sagte von Ribbeck: »Ich scheide nun ab.

Legt mir eine Birne mit ins Grab.«

Und drei Tage drauf, aus dem Doppeldachhaus,

Trugen von Ribbeck sie hinaus,

Alle Bauern und Büdner mit Feiergesicht

Sangen »Jesus meine Zuversicht«,

Und die Kinder klagten, das Herze schwer:

»He is dod nu. Wer giwt uns nu 'ne Beer?«

1 Herr

1 Havelland,Ein

6 von

3 Birnbaum

2 Herbsteszeit

9 Ribbeck

3 weit

1 »Junge,

1 Garten

1 Havelland.

1 Herbsteszeit,

1 Mittag

4 auf

2 war

1 wenn's

1 »Ich

5 'ne

2 Birnen

1 Grab.«

1 Junge