Seite 4 von 5
Verfasst: 06.08.2007 06:21
von PureLust
@Fluid Byte
Du scheinst nicht bedacht zu haben, dass eine Structur zur Compilezeit festliegen muss und nicht dynamisch wärend der Laufzeit "angelegt" wird.
@ReneMiner
Die Geschichte mit einer dynamischen Anzahl von Titeln für jeder Schallplatte kannst Du aber auch noch mit reinen PB-Bordmitteln lösen:
Die Schallplatten selber kannst Du wie von Dir gewünscht in einem normalen Arrey speichern und so über den Index darauf zugreiffen.
Um zu jeder Platte eine dynamische Anzahl an Titeln zu realisieren, werden einfach alle Titel in einer großen LinkedList gespeichert.
Bei dieser Liste ist es wichtig, dass sich alle zu einer Schallplatte gehörenden Titel hintereinander in der LinkedList befinden.
Dies ist aber recht einfach zu realisieren.
Um nun jederzeit auf die zu der jeweiligen Schallplatte gehörenden Titel zugreifen zu können brauchst Du in der Schallplatten-Struktur nur die Adresse des ersten und letzten zu dieser Platte gehörenden Titel-Elements zu speichern.
Hierdurch kannst Du die Anzahl der Titel die zu einer Platte gehören vollkommen dynamisch verwalten.
Wie Du das Ganze nun umsetzen kannst zeig' ich Dir mal an einem Beispiel:
Code: Alles auswählen
Structure LiedStruct
Titel.s
Interpret.s
Laenge.l
EndStructure
Structure eineSchallplatte
AlbumName.s
nTitel.l ; Anzahl der Titel
ErstesLLElement.l ; Zeiger auf erster Lied welches zu dieser Schallplatte gehört
LetztesLLElement.l ; Zeiger auf letztes Lied welches zu dieser Schallplatte gehört
EndStructure
Global Dim Platte.eineSchallplatte(9)
Global NewList EinLied.LiedStruct()
; ############################################################################################
; # Mit dieser Prozedur kannst Du einer Schallplatte jederzeit einen neuen Titel hinzufügen. #
; ############################################################################################
Procedure AddSong(Schallplatte, Titel.s, Interpret.s, Laenge.l)
If Platte(Schallplatte)\LetztesLLElement
ChangeCurrentElement(EinLied(), Platte(Schallplatte)\LetztesLLElement)
EndIf
AddElement(EinLied())
EinLied()\Titel = Titel
EinLied()\Interpret = Interpret
EinLied()\Laenge = Laenge
Platte(Schallplatte)\LetztesLLElement = @EinLied()
If Not Platte(Schallplatte)\ErstesLLElement : Platte(Schallplatte)\ErstesLLElement = @EinLied() : EndIf
Platte(Schallplatte)\nTitel + 1
EndProcedure
For n = 1 To 100
AddSong(Random(9), "Titel_"+Str(10000+Random(9999)), "Interpret_"+Str(10000+Random(9999)), Random(3*60) + 120)
Next n
For n = 0 To 9
Debug "Die Schallplatte Nr. "+Str(n+1)+" hat "+Str(Platte(n)\nTitel)+" Titel."
If Platte(n)\ErstesLLElement
ChangeCurrentElement(EinLied(), Platte(n)\ErstesLLElement)
Repeat
Debug " - "+EinLied()\Titel + " "+EinLied()\Interpret + " Länge: "+FormatDate("%ii:%ss",EinLied()\Laenge)
If @EinLied() = Platte(n)\LetztesLLElement : Break : EndIf
Until Not NextElement(EinLied())
EndIf
Next n
Gruß, PL.
Verfasst: 06.08.2007 19:52
von mk-soft
Würde eher zwei LinkedList erstellen und wie in einer Datenbank mit einer ID arbeiten und mit einer 1 zu unendlich verknüpfen.
Beide LinkedList nachher in zwei Tabellen speichern.
habe jetzt erst mal keine Zeit.
Mal ein ansatz dazu.
Code: Alles auswählen
Structure udtAlbum
ID.l
Name.s
Titel.s
EndStructure
Structure udtTitel
ID.l
Titel.s
Interpred.s
laenge.l
EndStructure
Global NewList Album.udtAlbum()
Global NewList Titel.udtTitel()
; ID für Album vergeben - muss eindeutig sein
ID = Date()
AddElement(Album())
With Album()
\ID = ID
\Name = "Steve Winwood"
\Titel = "XYZ"
EndWith
; Titel zu ID des Albums erstellen
For i = 1 To 10
AddElement(Titel())
With Titel()
\ID = ID ; Immer gleiche ID wie Album
\Titel = "Titel " + Str(i)
EndWith
Next i
FF
Verfasst: 06.08.2007 22:55
von PureLust
mk-soft hat geschrieben:Würde eher zwei LinkedList erstellen ...
ReneMiner hat geschrieben:; eine Liste wäre aber ungeeignet da ich die "Platten" über ihre
; Index-Nummern aufrufen will und muss.
Verfasst: 06.08.2007 23:11
von mk-soft
Index == ID
Wenn man noch weiter denk kann auch noch die Interpreten in einer dritten linkedlist ablegen und nur noch in der Titelliste mit InterpretID verbinden.
Ganz normale rev. Datenbank.
Verfasst: 06.08.2007 23:20
von PureLust
Ich interpretiere seine Aussage so, dass er einfach Platte 5, 7, 23, 5972 etc.
direkt per Array-Index ansprechen können möchte und eben nicht:
Weiterhin ist natürlich auch der Zugriff auf die zum Album gehörenden Titel durch die Verwendung der Zeigern erheblich schneller als wenn er auch dafür wiederum zig-tausende von Titeln durchlaufen muss:
Verfasst: 07.08.2007 01:58
von Kaeru Gaman
ich hör immer nur schneller, schneller...
(sagt ihr das woanders auch? ..und was sagt eure freundin dazu)
wenn ich per hand einen titel eingebe, den ich suchen will, oder eine index nummer,
dann ist die suche selbst beim komplett durchlaufen der liste schneller beendet,
als ich den titel eingetippt habe.
...klingt komisch, ist aber so.
und selbst wenn ich Ol'Quincy Jones wäre, und meine plattensammlung
nen extra stützbalken im boden bräuchte um nicht durchzubrechen,
wäre die komplettsuche immer noch schnell.
und wenn es mir wirklich nicht schnell genug geht,würde immer noch die zwei listen-lösung helfen.
leute... "schnell"... seid froh, dass ihr niemals in einem handschriftlichen drei lagerräume
großen archiv etwas suchen mußtet, bevor es billige computer gab.
...zwei listen..
in der einen liste stehen die indices und ein connector, die ist nach indizes sortiert.
per binärem suchen brauche ich maximal 8 zugriffe für 2^8 einträge.
in der zweiten liste stehen die titel und ein connector, die ist nach titel sortiert.
auch hier suche ich genauso schnell.
wenn ich nen neuen titel eingebe, dann werden beide listen neu sortiert und die connectoren (pointer auf elemente der anderen liste) aktualisiert.
also, allein der speichervorgang von neuen titeln dauert etwas länger.
und wie gesagt, kein arsch hat so viele platten sorry.
PS:
und für sowas gibt es datenbanksysteme, die machen sowas automatisch.
man braucht nicht immer das rad neu erfinden.
dafür arbeiten die leute schon seit jahrzehnten an effektiven datenbanksystemen.
früher war sowas nämlich wirklich nötig, weil die großrechner langsamere CPUs
hatten als jeder rechner den ihr letztes jahr aufn müll geschmissen habt.
und da war auch der zugriff beschränkt, da konnte man nicht einfach aufn knopp drücken und nen probelauf machen.
mein erstes programm auf nem rechner der mehr als 64KB Hauptspeicher hatte,
das war in Cobol, und ich durfte drei stunden auf den ausdruck warten,
ob mein billiges kleines proggi die liste auch richtig formatiert hat.
Verfasst: 07.08.2007 10:00
von mk-soft
Kaeru Gaman hat geschrieben:ich hör immer nur schneller, schneller...
(sagt ihr das woanders auch? ..und was sagt eure freundin dazu)
Danke!
Verfasst: 07.08.2007 10:20
von ReneMiner
Tja- das Problem ist nur das ich doch die Schallplatten und Lieder nur genommen habe um mein Problem rüberzubringen. In Wirklichkeit hab ich es natürlich mit Gruppen von Dreiecken und Vertizen zu tun deren Anzahl sich auch dauernd ändert und die ich ständig umsortieren, umindizieren, umrechnen und was weiss ich noch alles muss. So kommts das jede Gruppe eine unterschiedliche Menge an Mitgliedern haben kann und die hätte ich natürlich gerne übersichtlich nummeriert z.B. so hier:
Code: Alles auswählen
; structures sind ja ersichtlich, also:
;... ah - ein neues Mitglied...
Redim Gruppe(GruppenIndex)\Mitglied(NeueMitgliederAnzahl)
Gruppe(GruppenIndex)\Mitglied(MitgliedIndex)\Eigenschaften\Farbe=Farbe
Gruppe(GruppenIndex)\Mitglied(MitgliedIndex)\Eigenschaften\Grösse=Grösse
wäre ja ausreichend...
von solchen Konstrukten wie
Code: Alles auswählen
Bild(BildIndex)\Gruppe(GruppenIndex)\Mitglied(MitgliedIndex)\Eigenschaften\Farbe=Farbe
möchte ich da erstmal absehen und meine Erwartungen nicht zu hoch schrauben.
Ebenso gut wäre es wenn LinkedLists als structure-Elemente verwendbar wären - oder umgedreht: wenn man ein Array von LinkedLists erstellen könnte
Code: Alles auswählen
structure paarEigenschaften
Farbe.l
Grösse.l
endstructure
structure einMitglied
Eigenschaft.paarEigenschaften
blub.b
bla.l
endstructure
structure eineGruppe
Mitglied.LinkedList(einMitglied)
toll.s
prima.b
endstructure
; bzw. schön wäre auch das
CreateListArray(Listenname.Typ, 10)
; erstellt ein Array von 10 LinkedLists
...
ReCreateListArray(Listenname, 5)
; hier hätte ich nur noch 5 Listen
...
ReCreateListArray(Listenname, 15)
; und jetzt 15...
ResetList(Listenname[ListIndex]())
While NextElement(Listenname[ListIndex]())
Da wären eckige Klammern wohl angebracht und verständlich...
Verfasst: 07.08.2007 10:26
von Kaeru Gaman
das Problem ist nur das ich doch die Schallplatten und Lieder nur genommen habe um mein Problem rüberzubringen. In Wirklichkeit hab ich es natürlich mit Gruppen von Dreiecken und Vertizen zu tun deren Anzahl sich auch dauernd ändert und die ich ständig umsortieren, umindizieren, umrechnen und was weiss ich noch alles muss.
dann sag das doch bitte gleich...
du bist hier in einem programmiererforum, da
solltest du sagen, worum es dir geht,
(du musst hier keinen azubis im ersten halbjahr berufsschulinformatik ein EDV problem bildhaft schildern)
weil unterschiedliche problemstellungen nunmal unterschiedliche ansätze brauchen,
je nachdem um was für eine verwaltung es sich nun handelt.
wenn du jetzt noch mal ausführlicher erklärst, was deine spezifische problemstellung ist,
könnte es nämlich durchaus sein, dass jemand daherkommt:
"ach,
das willst du machen? das kann man ein bißchen anders besser lösen, guck mal hier, so hab ich das vor nem halben jahr gelöst"
...das kann er aber nur, wenn er weiß, dass du nicht deine plattensammlung sortieren willst.
Verfasst: 07.08.2007 10:27
von ts-soft
XML erfüllt alle Bedingungen, warum hörste nicht auf meinen Tip?