Darstellung= vielleicht besser: verschiedene Arten einen Baum zu erstellen

Hallo!
Was sind Vor-und Nachteile des niveauweise sequentiellen, projizierten bzw. dynamischen Darstellung eines Baumes?

Würde mich über schnelle Antworten freuen!

Zur Erklärung: niv.seq.= wenn man sich einen Baum vorstellt, wird eine Ebene nach der anderen abgearbeitet
proj.=wenn man die Knoten des Baumes "herunterfallen" lässt(dadurch ergibt sich dann die Reihenfolge)
dynamisch sollte klar sein..

Danke schon einmal!

So hab hier mal ein Programm entworfen ABER ES Klappt net Wenn jemand so nett wäre und die Fehler korrigieren würde...

Zitat

PROGRAM STAPELSCHLANGE;

TYPE STACK=RECORD
WERT:ARRAY[1..5] OF INTEGER;
ENDE:0..5;
END;

QUEUE=RECORD
WERT:ARRAY[1..5] OF INTEGER;
ANFANG:1..5;
ENDE:0..5;
END;

VAR STAPEL:STACK; SCHLANGE:QUEUE; Z:INTEGER;

PROCEDURE STAPELINIT(STAP:STACK);
BEGIN
STAPEL.ENDE:=0;
END;

PROCEDURE PUSH(VAR STAP:STACK; ZAHL:INTEGER);
BEGIN
WITH STAP DO
BEGIN
ENDE:=ENDE+1;
WERT[ENDE]:=ZAHL;
END;
END;

PROCEDURE POP(VAR STAP:STACK; VAR ZAHL:INTEGER);
BEGIN
WITH STAP DO
BEGIN
ZAHL:=WERT[ENDE];
ENDE:=ENDE-1;
END;
END;

PROCEDURE STAPELAUFBAUEN(STAP:STACK; ZAHL:INTEGER);
VAR I,N:INTEGER;
BEGIN
FOR I:=1 TO ZAHL DO
BEGIN
WRITELN('ZAHL EINGEBEN: '); READLN(N);
PUSH(STAP,N);
END;
END;

PROCEDURE STAPELZEIGEN(STAP:STACK);
VAR HILF:STACK;
BEGIN
STAPELINIT(HILF);
WHILE STAP.ENDE > 0 DO
BEGIN
POP(STAP,Z);
WRITE(Z,' ');
PUSH(HILF,Z);
END;
WHILE HILF.ENDE > 0 DO
BEGIN
POP(HILF,Z);
PUSH(STAPEL,Z);
END;
END;

PROCEDURE ENTER(SCHLANG:QUEUE; ZAHL:INTEGER);
BEGIN
WITH SCHLANG DO
BEGIN
ENDE:=ENDE+1;
WERT[ENDE]:=ZAHL;
END;
END;

PROCEDURE REMOVE(SCHLANG:QUEUE; ZAHL:INTEGER);
VAR I:1..5;
BEGIN
WITH SCHLANG DO
BEGIN
ZAHL:=WERT[ANFANG];
ANFANG:=ANFANG+1;
FOR I:=ANFANG TO ENDE DO WERT[I-1]:=WERT[i];
ANFANG:=ANFANG-1;
ENDE:=ENDE-1;
END;
END;

PROCEDURE SCHLANGEINIT(VAR SCHLANG:QUEUE);
BEGIN
WITH SCHLANG DO
BEGIN
ANFANG:=1;
ENDE:=0;
END;
END;

PROCEDURE SCHLANGEZEIGEN(SCHLANG:QUEUE);
VAR I:1..5; J:INTEGER; HILF:QUEUE;
BEGIN
SCHLANGEINIT(HILF);
WITH SCHLANGE DO
BEGIN
FOR I:=ANFANG TO ENDE DO
BEGIN
WRITE(WERT[ANFANG],' ');
REMOVE(SCHLANGE,Z);
ENTER(HILF,Z);
END;
END;
END;

BEGIN
CLRSCR;
STAPELINIT(STAPEL);
STAPELAUFBAUEN(STAPEL,5);
STAPELZEIGEN(STAPEL);
WHILE STAPEL.ENDE > 0 DO
BEGIN
POP(STAPEL,Z);
ENTER(SCHLANGE,Z);
END;
SCHLANGEZEIGEN(SCHLANGE);
READLN;
END.

Alles anzeigen

Google bringt mich da leider nicht weiter, da ich kein Programm finde das den Datentyp Stack und Queue gleichzeitig verwendet....
also ich weiß ja wie man ein Programm schreibt, in welchem man einen der beiden Datentypen verwendet, aber eben nicht zwei gleichzeitig

Ja, hallo nochmal!

Programm = siehe Überschrift (also Pascal)!

Also das mit Lifo und fifo ist mir bekannt...
nur wie kann ich jetzt "Stack" und "Queue" in einem Programm verwenden?
Was muss ich im Programmkopf beachten? Muss ich Queue und Stack separat deklarieren?
Und dann den Rest des Programms in Prozeduren realisieren (also für Stack und Queue getrennte Prozeduren )? Oder wie sieht das aus?

Hallo!

Ich stehe vor folgendem Problem:
Ich soll ein Programm schreiben, das die Datentypen statischer Stapel und statische Schlange in einem Programm mit einbindet...
Fragt bitte nicht nach dem Sinn eines solchen Programms (ich weiß auch noch nicht so recht was das bringen soll).
Vielleicht kann mir jemand ein paar Tipps zur Realisierung geben oder wenn's geht ein Programm, das die einfachen Grundoperationen besitzt, mal hier reinposten. Das wäre eine große Hilfe!

Danke schon mal!

So also nochmal zu 2:
Sag bescheid, wo ein Denkfehler liegt!
Ich probiers einfach, obwohl ich nicht ganz weiterkomme:
Also zuerst wird ja durch der ganze Sort-Stapel leer gemacht und auf den Min-Stapel übertragen, bis keine Elemente(nennt man das Elemente? oder kann ich knoten sagen?) mehr im Sort-Stapel sind. Dabei wird immer der Wert, auf den der Sort-Zeiger zeigt mit dem Wert, auf den der Min-Zeiger zeigt verglichen und wenn eben der Sort-Wert kleiner als Min ist, dann wird der Min-Wert (oder wie nennt man das? Objekt? Knoten? ka-korrektur bitte!!!) auf den Hilfs-Stapel gebracht und der Sort-Wert auf den Min-Stapel. Ist der Sort-Wert nicht kleiner als Min, kommt das Sort-Objekt/Knoten/oder what ever auf den Hilfsstapel, right?

Doch was dann? Wird Sort=Hilf gesetzt??????? und Hilf=Nil??? Wieso? Wann passiert das? Oder kommt man wieder in die If Bedinung??? Oder fängt das wieder bei Repeat an? ICH HABE KEINE AHNUNG!

Ja wie gesagt alles außer das Kleingeschriebene.
Also procedure loeschen, einfuegen und suchen funzt net! stehen allesamt unmittelbar vor dem Hauptprogramm!

So noch eine Frage (Bitte in Pascal):
Wie kann ich dynamische Stapel programmieren, dass Elemente gelöscht werden können oder neue Elemente an einer bestimmten Stelle eingefügt werden?
Bzw. wie kann ich es so progammieren, dass ein Element herausgesucht wird, dann genau dieses Element gelöscht wird oder ein neues Element nach dem herausgesuchten Element eingefügt wird??

In diesem Programm sind meine Versuche kläglich gescheitert! Schauts euch an und verbessert es, wenn möglich! Das Programm macht eigentlich gar nix!! Jedenfalls der Teil, den ich selbst gemacht hab!
Hab den Teil mal kleingeschrieben!

Hoffe auf Hilfe! Ja sry, tut mir Leid für die vielen posts heute!

Hallo! Hab hier ein Programm Stapelsort. Es sortiert halt die Zahlen.

Unklar ist mir die Prozedur "Stapelzeigen": Wieso wird hier nicht direkt ausgegeben, sondern noch zweimal umgestapelt?? Das bringt es doch nicht! Bei zweimal umstapeln, wär ich doch wieder beim alten?!?
Bitte Erklärung!

Außerdem unklar, wie das ganze im Hauptprogramm ab "REPEAT" abläuft! Was passiert da genau (also Schritt für Schritt). Wäre ganz nett, wenn mir das jemand erklären könnte. Ich weiß zwar, dass irgendwie "umgestapelt" wird aber die Reihenfolge ist mir nicht ganz klar und wie das genau passiert!

Ich hoffe mir kann jemand helfen.

MfG
Johannes

Was versteht man unter variante Records ? Was ist der Unterschied zu normalen Records?

Ich finde leider keine Definitionen im Netz.

Würde mich über eine schnelle Antwort freuen.

Zum Dreieckstausch: Wie läuft das genau ab? Was ist P[i]/P[k] beispielsweise beim ersten Durchlauf??
for i:=k to n do
begin
h:=P[i];
P[i]:=p[k];
P[k]:=h;
permu(P,k+1);

Also zunächst ist k=1 also i=1 oder?
Was ist nun hier P[i]? Was ist P[k] ? Ist das nur
eine Zahl? sind das direkt mehrere?
Ich versteh ja das P[i] mit P[k] getauscht wird.
Aber mir ist eben nicht ganz klar was die Werte
darstellen und wie das ganze genau abläuft.
Also die Schleife for i:=k to n do wird zuerst mit 1 durchlaufen. Und dann wird nochmal die Procedure gestartet, mit einem um 1 größeren k-wert? oder läuft die schleife zuerst zuende?
Wie genau entstehen bei dem Programm die Permutationen???

Hallo!
Es geht um ein Pascal-Programm, das die Permutationen von 1-4 ausgeben soll. Dabei ist mir nicht ganz klar, wie das Ganze funktioniert. Es wäre nett, wenn mir jemand das Programm erklären könnte.

Insbesondere kann ich nicht nachvollziehen, warum die Variablendeklaration (die der Prozedur von I und H) nicht im Prozedurkopf sondern darunter stehen (wann muss ich sie in den kopf schreiben, wann nicht?).
Desweiteren sind mir die Schleifen nicht ganz klar, sowie der Dreieckstausch:

program permutation;

uses crt;

const n=4;

type bereich=1..N;
feldtyp=array[bereich] of bereich;
var i:bereich;
pm:feldtyp;

procedure permu(p:feldtyp; k:bereich);

var i,h:bereich;
begin
if k=n then
begin for i:=1 to n do write(' ',P[i]);
writeln;
end
else
for i:=k to n do
begin
h:=P[i];
P[i]:=p[k];
P[k]:=h;
permu(P,k+1);
end;
end;
begin
clrscr;
for i:=1 to n do pm[i]:=i;
permu(Pm,1);
readln;
end.

Also wie gesagt, wäre nett wenn mir jemand das Ganze möglichst bald erklären könnte.