Liste von Arrays

[mucki64]

Hallo,

ich suche nach einer geeigneten Datenstruktur, um in einem rekursiven Programm Strings einzusammeln.
Die Methode sollte einen String, besser eine TStringList oder ein Array of Strings zurückgeben.
Dabei müssen Teillisten zusammengefaßt werden. Wie geht das elegant? Hier der Algorithmus:

Delphi-Quellcode:

function TBaum.Traversiere(Z: TElement): TStringList;
var Inhalt: TStringList;

Begin
     Inhalt := TStringList.Create;
     IF Z<>NIL Then
     Begin
          Inhalt.Add(Traversiere(Z.gibSohn(ToLinks)));    // geht nicht, da Add nur einen String anhängt
          if Z<>Wurzel then
               Inhalt.Add(Z.gibInhalt);
          Inhalt.Add(Trraversiere(Z.gibSohn(ToRechts)));
     End;
Traversiere := Inhalt;
End;

[bra]

Die TStringList sollte als var-Parameter übergeben werden, sonst hast du hinterher massig TStringLists, die im Speicher rumhängen.

Delphi-Quellcode:

procedure TBaum.Traversiere(Z: TElement; var AList: TStringList);
...

[Blup]

Die Direktive "var" ist hier überflüssig, da Objektvariablen nur die Referenz(Pointer) auf das eigentlich Objekt enthalten.

[haentschman]

Moin...

Denke auch an die Freigabe der TStringlist Inhalt. Bedenke, das du bei jedem rekursiven Aufruf eine neue Instanz dazu bekommst (bekommen würdest).
Besser: Die Liste die den Result repräsentiert außerhalb der Funktion verwalten(wie schon erwähnt z.B. als Parameter übergeben oder als privates Feld)

[Sir Rufo]

Eine Möglichkeit (garantiert ohne MemLeaks) wäre

Delphi-Quellcode:

function TBaum.Traversiere( aElement: TElement): TStringList;
var
  lSubResult: TStrings;
begin
  Result := TStringList.Create;
  try
    if Assigned( aElement ) 
    then
      begin
        lSubResults := Traversiere( aElement.gibSohn( ToLinks ) );
        try
          Result.AddStrings( lSubResults ); 
        finally
          lSubResults.Free;
        end;

        if aElement <> Wurzel 
        then
          Result.Add( aElement.gibInhalt );

        lSubResults := Traversiere( aElement.gibSohn( ToRechts ) );
        try
          Result.AddStrings( lSubResults ); 
        finally
          lSubResults.Free;
        end;
     end;
  except
    Result.Free;
    raise;
  end; 
end;

[mucki64]

Ja, es lohnt sich wirklich, den Speicher nicht für eine neue Instanz Inhalt pro Aufzuf verschwenden, danke für die guten Vorschläge.
Mein Hauptproblem aber bleibt: Inhalt.Add() akzeptiert nur einen String, aber keine TStringList. Somit läßt sich meine Methode gar nicht kompilieren.

[Sir Rufo]

Zitat von mucki64:

Ja, es lohnt sich wirklich, den Speicher nicht für eine neue Instanz Inhalt pro Aufzuf verschwenden, danke für die guten Vorschläge.
Mein Hauptproblem aber bleibt: Inhalt.Add() akzeptiert nur einen String, aber keine TStringList. Somit läßt sich meine Methode gar nicht kompilieren.

Warum habe ich wohl TStrings.AddStrings verwendet?

[mucki64]

Danke, das habe ich übersehen. Deine Lösung leistet das Gewünschte.

[jfheins]

Zitat von Sir Rufo:

Eine Möglichkeit (garantiert ohne MemLeaks) wäre
*snip*

Aber das ist ja auch suboptimal. Da wird ja für jeden Knoten eine neue Stringlist erstellt, und dann steigen die Add-Aufrufe mit der Knotenanzahl stark (quadratisch?) an...

Besser wäre es imho, die StringListe als Parameter zu übergeben. Der Aufrufer muss da vorher ein gültiges Objekt hineinstecken und hat konsequenterweise danach die Aufgabe, dasselbe aufzuräumen.
In etwa so:

Delphi-Quellcode:

function TBaum.Traversiere( aElement: TElement, const InhaltsListe: TStringList) : TStringList;
begin
   if Assigned(aElement) then
   begin
      Traversiere(aElement.gibSohn(ToLinks), InhaltsListe));

      if aElement <> Wurzel then // Warum eigentlich das hier??
        InhaltsListe.Add(aElement.gibInhalt);

      Traversiere(aElement.gibSohn(ToRechts), InhaltsListe);
   end;
   Result := InhaltsListe
end;