Nachträgliche Sortierung von Datensätzen

  • Nachträgliche Sortierung von Datensätzen

    Hi,

    ich bin gerade an einem Script dran, dass eine Baumansicht erstellt.

    Das Script generiert die Struktur für die Darstellung via Javascript.

    Diese sollte beispielsweise so aussehen:

    --------------------------------------------------------------------------------
    Ebene1 = (root, ("Name Ebene 1"))
    Ebene2_1 = (Ebene1, ("Name Ebene 2_1"))
    Ebene3_1 = (Ebene2_1, ("Name Ebene 3_1"))
    Ebene3_2 = (Ebene2_1, ("Name Ebene 3_2"))
    Ebene4 = (Ebene3_1, ("Name Ebene 4"))
    Ebene2_2 = (Ebene1, ("Name Ebene 2_2")
    --------------------------------------------------------------------------------

    Das ist wie folgt zu lesen:

    Ebene = (übergeordnete Ebene,("Dargestellter Name der Ebene im Baum"))

    Nun das Problem; das Script erzeugt die Knoten sortiert nach Namen (Muss so sein); Das Ergebnis in einem konkreten Fall sieht so aus:


    --------------------------------------------------------------------------------
    Ebene1 = (root, ("Name Ebene 1"))
    Ebene4 = (Ebene3_1, ("Name Ebene 4"))
    Ebene2_1 = (root, ("Name Ebene 2_1"))
    Ebene3_1 = (Ebene2_1, ("Name Ebene 3_1"))
    Ebene3_2 = (Ebene2_1, ("Name Ebene 3_2"))
    Ebene2_2 = (root, ("Name Ebene 2_2"))
    --------------------------------------------------------------------------------

    Das bedeutet, der Baum kann nicht, bzw. nur bis zur 1. Ebene aufgebaut werden, da der übergeordnete Knoten von Ebene 4 (in der 2. Zeile des obigen Codes) erst in Zeile 4 bekannt ist.

    Das ist ein Problem. In diesem Beispiel könnte man zwar einfach sortieren, aber in einem realistischen Fall sieht das so aus:

    --------------------------------------------------------------------------------
    GMC_TEST = (root, ("GMC TEST"))
    Litho = (Test_1_2, ("Litho"))
    Test_1 = (GMC_TEST, ("Test 1"))
    Test_1_1 = (Test_1, ("Test 1-1"))
    Test_1_2 = (Test_1, ("Test 1-2"))
    Test_2 = (GMC_TEST, ("Test 2"))
    Test_3 = (GMC_TEST, ("Test 3")
    --------------------------------------------------------------------------------


    Litho steht also einfach an der falschen Stelle und müsste eigentlich unbedingt nach Test_1_2 kommen, da zu dem Zeitpunkt, bei dem Litho geschrieben wird, der zugewiesene übergeordnete Knoten Test_1_2 überhaupt nicht bekannt ist.

    Das liegt daran, dass die Daten bei der Abfrage sortiert werden, was unbedingt notwendig ist.

    Wie kann ich denn jetzt beispielsweise Litho wieder richtig einsortieren??

    Also so:

    --------------------------------------------------------------------------------
    GMC_TEST = (root, ("GMC TEST"))
    Test_1 = (GMC_TEST, ("Test 1"))
    Test_1_1 = (Test_1, ("Test 1-1"))
    Test_1_2 = (Test_1, ("Test 1-2"))
    Litho = (Test_1_2, ("Litho"))
    Test_2 = (GMC_TEST, ("Test 2"))
    Test_3 = (GMC_TEST, ("Test 3")
    --------------------------------------------------------------------------------


    Irgendwelche Ideen?

    Ich hoffe ich habe mich verständlich ausgedrückt.
    Um Rekursionen zu verstehen, muss man zuerst Rekursionen verstehen...
  • musst du unbedingt mit javascript sortieren, oder nur ausgeben?
    kenne mich mit JavaScript Bäumen nicht so aus

    schonmal was von JSON gehört??
    Damit kann man JavaScript Klassen in einen String verwandeln und mit eval() wieder zurück verwandeln..
    läuft über XML..

    Steht weit oben auf meine "get2know Liste", habs aber selber noch nicht angewendet

    Ein Beispiel von der englischen WIki Seite (http://en.wikipedia.org/wiki/JSON):

    Quellcode

    1. myObject = n;
    2. http_request.open("GET", url, true);
    3. http_request.onreadystatechange = function() {
    4. if (http_request.readyState == 4) {
    5. if (http_request.status == 200) {
    6. var json_data = http_request.responseText;
    7. var the_object = eval("(" + json_data + ")");
    8. } else {
    9. alert("There was a problem with the URL.");
    10. }
    11. http_request = null;
    12. }
    13. }
    14. http_request.send(null);
    Alles anzeigen


    Hilft dir das irgendwie?
    da du im PHP FOrum postest, dachte ich mir, dass du das XML vielleicht auch lieber mit AJAX und PHP verarbeiten möchtest...
  • Hi,

    ne, das sollte schon mit PHP sortiert werden, wichtig ist die Ausgabe in der richtigen Form und das kann ich ja einfach irgendwann über echo oder print machen.

    Ich dachte evtl. daran, die einzelnen Strings aufzusplitten und in Arrays einzufügen, die dann richtig sortiert werden; kommt aber momentan nicht drauf, wie ich anfangen soll.
    Um Rekursionen zu verstehen, muss man zuerst Rekursionen verstehen...
  • Wenn man sich das ansieht

    Ebene = (übergeordnete Ebene,("Dargestellter Name der Ebene im Baum"))

    dann erkennt man ja, dass zuerst alle "übergeordneten" Ebenen ausgegeben werden müssen. Das bedeutet, wenn die übergeordnete Ebene nicht vorhanden ist, kann der Baum nicht weiter sequentiell aufgebaut werden.

    Um das zu lösen muss zunächst beim Einfügen jedes neuen Knotens (oder jeder neuen Zeile, siehe Beispiele oben) überprüft werden, ob der in [übergeordnete Ebene] angegebene Knoten bereits vorhanden ist bzw. die Zeile bereits geschrieben wurde.
    Wenn das so ist, kann der neue Knoten bzw. die neue Zeile geschrieben werden. Wenn das nicht so ist, dann muss dieser Knoten zwischengespeichert werden und kann erst geschrieben werden, wenn ein Knoten existiert, der [übergeordnete Ebene] in dem zwischengespeicherten Knoten entspricht.

    Ist doch richtig oder?

    Aber wie implementiert man sowas in PHP, so dass am Ende wirklich nur die einzelnen Zeilen wie im obigen Beispiel ausgegeben werden?

    (Das hat übrigens nichts mit Ajax oder XML zu tun, hier geht es alleine nur um die Ausgabe der einzelnen Zeilen in der richtigen Reihenfolge, siehe oben)
    Um Rekursionen zu verstehen, muss man zuerst Rekursionen verstehen...
  • du willst doch quasi einen baum in arrays abbilden, oder?
    Stell ich mir nicht sehr perfomant vor *g*

    ich glaub mit den DOM Funktionen in PHP kennst du dich besser aus. Gibts da keine Möglichkeit?

    Ansonsten würd ich mal nach einer Baum Implementierung bei
    www.phpclasses.org oder www.koders.com suchen

    bei phpclasses.org gibts z.B. nen AVL Tree
  • Performance ist egal, das sind eh nur maximal 20 Zeilen oder so ... das geht schnell ...


    Aber ein Ansatz wäre nicht schlecht?

    Wie mache ich das? Gibt es 2D Arrays in PHP? Oder irgendeine andere Struktur mit der ich die einzelnen Zeilen in ihre Bestandteile ausplitte, eine Beziehung herstelle und dann iteriere?
    Um Rekursionen zu verstehen, muss man zuerst Rekursionen verstehen...