Menu schließen

struktogramm

Frage: struktogramm
(1 Antwort)

 
hallo ich hätte eine frage wie würde das struktogramm von dem hier aussehen:

Die Sortieralgorithmen sind als Methoden einer statischen Liste (Feld) ausgeführt.


* BubbleSort_1
* BubbleSort_2
* BubbleSort_3
* ShakerSort
* StraightSelection
* QuickSort

procedure Tauschen (var E1, E2 : TElement);
(* ------------------------------------ *)
var
hilf : TElement;
begin
hilf:= E1;
E1 := E2;
E2 := hilf
end;

procedure TWortListe.Bubblesort1;
(* -------------------------------------------------------------------- *)
(* Auftrag: lineares Sortieren durch systematisches Vergleichen aller *)
(* Elemente und Tauschen mit dem nachfolgenden Element *)
(* Vorher : Liste ist initialisiert *)
(* Nachher: Liste ist aufsteigend sortiert *)
(* -------------------------------------------------------------------- *)
var
Durchlauf,
i : integer;

begin
for Durchlauf := 1 to (Listenlaenge - 1) do
begin
for i := 1 to (Listenlaenge - 1) do
begin
if Kollektion[i] > Kollektion[i+1]
then Tauschen(Kollektion[i], Kollektion[i+1]);
end;
end; (* for Durchlauf *)
end;

procedure TWortListe.Bubblesort2;
(* ------------------------------------------------------------------- *)
(* Auftrag: lineares Sortieren durch Vertauschen des nachfolgenden *)
(* Elements im Restfeld, das von hinten verkleinert wird. *)
(* Vorher : Liste ist initialisiert *)
(* Nachher: Liste ist aufsteigend sortiert *)
(* -------------------------------------------------------------------- *)
var
Durchlauf,
i,
Endmarke : integer;

begin
Endmarke := ListenLaenge - 1;
for Durchlauf := 1 to (ListenLaenge - 1) do
begin
for i := 1 to (Endmarke) do
begin
if Kollektion[i] > Kollektion[i+1]
then
begin
Tauschen(Kollektion[i], Kollektion[i+1]);
end;
end;
Endmarke := Endmarke - 1;
end;
end;

procedure TWortListe.Bubblesort3;
(* ------------------------------------------------------------------ *)
(* Auftrag: lineares Sortieren durch Vergleichen und Vertauschen des *)
(* nachfolgenden Elements bis nicht mehr getauscht wird. *)
(* Endmarke rueckt vor und verkleinert Restfeld *)
(* vorher : Kollektion ist initialisiert *)
(* nachher: Kollektion ist aufsteigend sortiert *)
(* ------------------------------------------------------------------ *)
var
y,
Endmarke : integer;
IstSortiert : boolean;

begin
Endmarke := Listenlaenge - 1 ;
IstSortiert := false;

while NOT IstSortiert do
begin
IstSortiert := true ;

for y := 1 to endmarke do
begin
if Kollektion[y] > Kollektion[y+1]
then
begin
IstSortiert := false;
Tauschen (Kollektion[y], Kollektion[y+1]);
end;
end;

Endmarke := Endmarke - 1; (* Restfeld verkleinern *)
end;
end;

procedure TListe.shakersort1;
(* ------------------------------------------------------------------- *)
(* Aufgabe: *)
(* lineares Sortieren durch Vergleichen und Vertauschen des *)
(* nachfolgenden Elements. *)
(* Das Feld wird abwechselnd von links nach rechts durchlaufen, *)
(* dabei die Feldgrenzen nach innen verkleinert solange die linke *)
(* Grenze kleiner ist als die rechte. *)
(* vorher : Kollektion ist initialisiert *)
(* nachher: Kollektion ist aufsteigend sortiert *)
(* ------------------------------------------------------------------- *)

var
y,
linkeGrenze,
rechteGrenze,
tauschPos : integer;

begin
linkeGrenze := 1;
rechteGrenze := ListenLaenge - 1;
tauschPos := linkeGrenze;

while linkeGrenze < rechteGrenze do
begin
for y := linkeGrenze to rechteGrenze do
begin
if Kollektion[y] > Kollektion[y+1]
then
begin
Tauschen(Kollektion[y], Kollektion[y+1]);
tauschPos := y;
end;
end; (* for y *)
rechteGrenze := tauschPos - 1;

for y := rechteGrenze downto linkeGrenze do
begin
if Kollektion[y] > Kollektion[y+1]
then
begin
Tauschen(Kollektion[y], Kollektion[y+1]);
tauschPos := y;
end;
end; (* for y *)
linkeGrenze := tauschPos +1;
end; (* while *)
end;

procedure TListe.auswahlsort;
(* ------------------------------------------------------------------- *)
(* Aufgabe: lineares Sortieren durch direkte Auswahl und Vertauschen *)
(* der Position. *)
(* vorher : Kollektion ist initialisiert *)
(* nachher: Kollektion ist aufsteigend sortiert *)
(* ------------------------------------------------------------------- *)

var
i,
y,
indexmin : integer; (* Index des kleinsten Elem. *)

begin
for i := 1 to (ListenLaenge - 1) do
begin
indexmin := i;

for y := (i + 1) to ListenLaenge do
begin (* im Restfeld das kleinste *)
if Kollektion[y] < Kollektion[indexmin] (* Element suchen *)
then indexmin := y;
end; (* for y *)

Tauschen(Kollektion[i], Kollektion[indexmin]); (* Positionen tauschen *)
end; (* for i *)
end;

procedure TWortListe.Quicksort(anfang, ende: Word);
(* ------------------------------------------------------------------- *)
(* Auftrag: Feld teilen und nach mittlerem Vergleichselement grob *)
(* vorsortieren. Linke und rechte Haelfte rekursiv bearbeiten *)
(* Vorher : Kollektion ist initialisiert *)
(* nachher: Kollektion ist aufsteigend sortiert *)
(* ------------------------------------------------------------------- *)
var LinkerZeiger,
RechterZeiger : word;
VergleichsElement : string;

begin
LinkerZeiger := anfang;
RechterZeiger := ende;
VergleichsElement := Kollektion[(LinkerZeiger + RechterZeiger) div 2];

repeat
while (Kollektion[LinkerZeiger] < VergleichsElement) do //auf der linken
begin // Seite einen
LinkerZeiger := LinkerZeiger + 1; // `Falschen` suchen
end;

while (Kollektion[RechterZeiger] > VergleichsElement) do //auf der rechten
begin //Seite einen
RechterZeiger := RechterZeiger-1; // `Falschen` suchen
end;

if LinkerZeiger <= RechterZeiger // haben sich noch nicht ueberkreuzt
then // dann tauschen und eins weiter
begin
Tauschen (Kollektion[LinkerZeiger], Kollektion[RechterZeiger]);
LinkerZeiger := LinkerZeiger + 1;
RechterZeiger := RechterZeiger - 1;
end; (* if *)
until RechterZeiger < LinkerZeiger; // Grobsortierung beendet

if anfang < RechterZeiger // mehr als 1 El. vorhanden
then quicksort(anfang, RechterZeiger);

if LinkerZeiger < ende
then quicksort(LinkerZeiger, ende);

end;
GAST stellte diese Frage am 11.01.2010 - 21:25


Autor
Beiträge 0
13
Antwort von B-onkel91 (ehem. Mitglied) | 08.02.2010 - 19:55
OK Quellcode ist ja genug da... Bubble sort standard Algorhytmus !

Mach dir mal bitte die Funktionsweise klar,
zeichne eine Tabelle..
und mach pro durchlauf eine neue Tabelle und schreib auf was sich ändern....


Und dann siehst du schon was genau passiert... dann sollte ein struktogramm net mehr schwer zu zeichnen sein !

Danach klickst du auf diese Seite :D
http://www.tinohempel.de/info/info/ti/bubblesort.htm

Verstoß melden
Hast Du eine eigene Frage an unsere Informatik-Experten?

> Du befindest dich hier: Support-Forum - Informatik
ÄHNLICHE FRAGEN: