Verzweigte Datenstruktur "anstrengender" ?

[Neutral General]

Hi,

Habe gerade eine Klasse, die eine Liste besitzt, in der beliebig viele instanzen derselben Klasse gespeichert sind, welche natürlich wiederrum alle eine Liste haben, die beliebig viele Items besitzen kann.

Also alles sehr verschachtelt. Beispielklasse:

Delphi-Quellcode:

TBeispielListe = class(TObjectList)

end;

TBeispiel = class
public
  Name: String;
  Beispiele: TBeispielListe;
end;

Soweit in Ordnung. Wenn ich aber jetzt z.B. nach einer Beispiel Instanz mit einem gewissen Namen suchen will, dann muss ich diesen ganzen Datendschungel rekursiv durchsuchen.

In meinem Fall wäre es denkbar, alle Instanzen von TBeispiel in einer TBeispielListe zu speichern wenn ich die Beispielklasse um 1-2 Properties erweitern würde und dafür die "Beispiele: TBeispielliste" rausnähme.

Bei dieser Liste könnte ich dann einfach alle Daten von vorne bis hinten durchgehen und somit durchsuchen.

Welche dieser Lösungen ist besser? Bzw. was ist performanter und was ist schneller?

Gruß
Neutral General

[Hansa]

Dein TBeispiel hat dann jeweils eigene Liste. Halte besser die Objekte und die ObjectList auseinander. Also Objekte erzeugen und die Liste damit füllen. Nicht noch die Listen mit Listen füllen.

[Neutral General]

Nein so meine ich das auch nicht.

Ein TBeispiel hat eine Liste in der TBeispiele gespeichert werden. Diese TBeispiele haben wiederrum jeweils eine Liste in der TBeispiele gespeichert werden.

also als anschauliches Beispiel:

Code:

- [color=#3f00ff]TBeispiel[/color]
   - [color=#00ff00]TBeispiel[/color]
   - [color=#00ff00]TBeispiel[/color]
      - [color=#ff001f]TBeispiel[/color]
- [color=#3f00ff]TBeispiel[/color]
   - [color=#00ff00]TBeispiel[/color]
      - [color=#ff001f]TBeispiel[/color]
      - [color=#ff001f]TBeispiel[/color]
         - [color=#ffff3f]TBeispiel[/color]
             - [color=#ff00ff]TBeispiel[/color]
      - [color=#ff001f]TBeispiel[/color]
   - [color=#00ff00]TBeispiel[/color]

Eine Baumstruktur quasi. Wie ein TreeView.

[Hansa]

Zitat von Neutral General:

Eine Baumstruktur quasi. Wie ein TreeView.

Ja, warum nimmst du denn keine Baumstruktur ? Die TObjectList ist eher linear zu gebrauchen. Man kann zwar auch aus Listen einen Baum bauen, aber wozu ? Mich interessieren nur die Kirschen, egal an welchen Ästen die hängen. Am besten kommen die direkt aus der Tüte oder einem Korb.

[Neutral General]

Also entweder reden wir aneinander vorbei... Wie sieht denn sonst eine Baumstruktur aus. Hast du (oder sonst jemand) vielleicht ein Pseudocode-Beispiel?

[Hansa]

Baum :

Code:

- [color=#3f00ff]AST[/color]
   - [color=#00ff00]AST[/color]
      - [color=#ff001f]AST[/color] -> Daten
      - [color=#ff001f]AST[/color]
         - [color=#ffff3f]AST[/color]
             - [color=#ff00ff]AST -> Daten[/color]
      - [color=#ff001f]AST -> Daten[/color]
   - [color=#00ff00]AST -> Daten[/color]

Kann aber durchaus sein, dass wir aneinander vorbei reden.

[Roachford]

Delphi-Quellcode:

type
  TExample = class;

  TExampleList = class(TObjectList)
  protected
    function GetItem(Index: integer): TExample;
    procedure SetItem(Index: integer; AObject: TExample);
  public
    property Items[index: integer]: TExample read GetItem write SetItem; default;
  end;

  TExample = class
  private
    fItems: TExampleList;

  public
    constructor Create;
    destructor Destroy; override;

    property Items: TExampleList read fItems;
  end;

...

Delphi-Quellcode:

function TExampleList.GetItem(Index: integer): TExample;
begin
  result := TExample(inherited GetItem(Index));
end;

procedure TExampleList.SetItem(Index: integer; AObject: TExample);
begin
  inherited SetItem(Index, AObject);
end;

...

constructor TExample.Create;
begin
  inherited;

  fItems := TObjectList.Create;
end;

destructor TExample.Destroy;
begin
  fItems.Free;

  inherited;
end;

----------------------------

Delphi-Quellcode:

var
  lTest: TExample;
begin
  lTest := TExample.Create;
  try
    lTest.Items.Add(TExample.Create);
    lTest.Items[0].Items.Add(TExample.Create);

    // zu finden unter: lTest.Items[0].Items[0]
  finally
    lTest.Free; 
  end;
end;

Um es dann angenehmer zu machen mit der Entfernung der Items aus den Listen, könntest du in TExample dir vermerken in welcher Liste er selbst hängt oder Alternativ welcher TExample sein Parent ist. Dann könntest du im Destructor von TExample Self in der Liste vom Parent entfernen (aber aufpassen, dass du das Element nicht doppelt freigeben lässt: du befindest dich dann schon im Destructor. Also unbedingt Extract() verwenden und nicht Remove!!). Das hätte den schicken Nebeneffekt, dass du ein Element nur freigeben brauchst und müsstest es nicht mehr explizit in der Liste zu suchen um es zu entfernen.

[Neutral General]

Zitat von Roachford:

[...]

Diese Struktur habe ich auch in meinem Programm verwendet - Das meine ich die ganze Zeit ^^

Das mit dem freigeben etc ist nicht so das Problem. Eher das zugreifen und ob das nicht sehr aufwendig ist für den PC.
Abgesehen davon, dass ich es auch z.T. schwer finde gezielt auf einzelne Items zuzugreifen. Also ich kriegs schon hin, aber das ganze ist dann immer ein ganzes Stück aufwendiger als bei "normalen" Listen.

[Roachford]

Zitat von Neutral General:

Diese Struktur habe ich auch in meinem Programm verwendet - Das meine ich die ganze Zeit ^^

Schrecklich, du zwingst einen dazu, Beiträge zu lesen.

Ok, dann halt mal eine Antwort auf deine Frage: Eine ewig lange Liste durchzugehen, welche unsortiert ist, dauert entsprechend auch seine Zeit. Wenn du die Einträge anhand gewisser Merkmale priorisieren kannst, dann kannst du diese schon besser in der Liste einfügen und somit auch performanter darauf zugreifen.

Bei einer Baumstruktur hingegen kannst du mit den Verzweigungen arbeiten und somit eine Wegfindung zu dem richtigen Ast machen, weil du auf dem Weg dahin, bestimmte Äste und Zweige ausschliessen kannst und somit nicht absuchen brauchst.

In beiden Fällen benötigst du aber Merkmale anhand derer du die Einträge priorisieren/unterscheiden kannst.

[SirTwist]

Vielleicht erzählst Du uns einfach mal, was genau Du machen willst. Es ist nämlich ziemlich müßíg, Dich über die Vor- und Nachteile einer bestimmten Datenhaltung beraten zu wollen, wenn niemand weiß, was genau Du abspeichern willst.

Wenn Du z.B. alle Bodenplatten eines mehrgebäudigen Firmenkomplexes erfassen willst, kann es durchaus sinnvoll sein, eine Klasse TGebäude zu haben, die eine Liste von TStockwerk enthält, deren Instanzen wiederum Listen von TRaum enthalten und im Raum gibts eine Liste der Bodenplatten....

Mal so als ganz konkretes Beispiel aus der täglichen Praxis...

Gruß,
SirTwist