Variablen nach Werten sortieren

[Edmond Dantès]

Guten Abend,

momentan zerbreche ich mir den Kopf bei einem kniffligen Problem:
Und zwar möchte ich die Variablen 1 bis 20 nach ihrem Wert absteigend sortieren und die neue Reihenfolge in den Variablen 21 bis 40 speichern. Allerdings sollen in den neuen Variablen nicht die Werte selbst absteigend gespeichert werden, sondern nur die Nummern der jeweiligen Variablen, um diese später referenzieren zu können. Welche wäre die effizienteste Methode, um dieses Problem zu lösen?! Vielen Dank schonmal für eure Hilfe!

[Brei]

Methoden:
1.: Such den Kleinsten Wert aus Liste 1 (var 1 - 20), welcher nicht in Liste 2 (21-40) steht.
2.: Häng diesen Wert an die Liste 2 an.

Umsetzung:
(Der erste Makertaugliche ansatz, der mit einfiel, probier mal ob er dir performant genug ist.)
Schleife [Abbruch wenn Platz 40 beschrieben ist](
(methode 1: )
"bisher Kleinstes" = 9999999;
Schleife [für i von 1 bis 20] (
schau auf Wert an Stelle i;
vergleiche ihn mit dem "bisher Kleinstes"; "bisher Kleistes" = der kleinere der Beiden Werte("bisher Kleistes" und dem Wer an Stelle i) ;
Schau ob i in Liste 2 steht.
falls nein: Merke dir das i in einer Variable.("X")
falls ja: ignoriere den Fund. )
Was jetzt in X steht ist der nächst-Kleiste Wert.

(methode 2: )
i=0;
Schleife [bis k=0](
k=Wert an Stelle i

i=i+1 ; )
Wert an Stelle i = Der Fund von oben... ("X")


)

Keine Besonders Effiziente Sortierung (mit O von X^2), aber hab noch nie versucht Effizient mit dem Maker zu sortieren...
Sollte es dir zu inperformant sein, google einfach mal nach gängigen Sortieralgorithmen

So viel zur Theorie, lass mich wissen wie du damit klargekommen bist...

[DNKpp]

ein 0.0 sind auch meines wissen 0.03 sec.
weiß ja nicht, wo du das platziert hast, aber wenn du es nach jeder fertig sortierten zahl machst, wären das 20*0.03sec = 0.6sec, dazu noch das langsamere rechnen des makers, dann wird das schon recht langsam.

[ETeCe]

Hätte einen ähnlichen Ansatz:

- Gehe nacheinander alle Elemente der ersten Liste (Variablen 1-20) durch und speichere jeweils dessen ID und Wert in 2 neuen Variablen (aktuelle ID und aktueller Wert)
- Gehe damit jeweils die zweite Liste (Variablen 21-40) nach folgenden Kritierien durch:
- - Ist der Eintrag in der zweiten Liste gleich 0 (noch keine Variable eingetragen): trage dort die aktuelle ID ein und breche die Schleife ab. Anderenfalls...
- - Ist der Wert der eingetragenen Variablen kleiner als der "aktuelle Wert": trage an dieser Stelle die "aktuelle ID" ein, der vorherige Eintrag wird zur neuen "aktuellen ID" (und wird somit im Folgenden weiter aufgerückt)


Hätte zumindest den Vorteil dass (wenn ich Brei richtig verstanden hab) du nicht jedes Mal die erste Liste nach dem kleinsten Element durchsuchen musst... Allerdings habe ich auch keine Ahnung wie schnell das Ganze im Maker ist.

[DNKpp]

deine methode hat einen kleinen denkfehler:

angenommen du hast schon 3 zahlen in der zweiten liste (z.b. 3,5,8 )
jetzt kommt aus der ersten list die zahl 1.

1. durchlauf:
1 < 3 also wird 3 gespeichert
2. durchlauf
3 < 5 also wird 5 gespeichert
3. durchlauf
5 < 8 also wird 8 gespeichert

wie du siehst brauchst du im schlechtesten fall immer die anzahl durchläufe, die bereits schon in der liste gespeichert wurden.

da ist denke ich ein durchsuchen der unsortierten variabeln am effizientesten, und weniger fehler anfällig.

[ETeCe]

In dem Sinne hast du natürlich recht, die innere Schleife wird insgesammt 1 + 2 + ... + 20 = 210 Mal durchlaufen, egal in welcher Reihenfolge die Zahlen eingefügt werden.

So wie ich es verstanden habe wäre die Alternative aber ebenfalls 20 Mal die erste Liste komplett zu durchlaufen um den jeweils nächstkleineren Wert zu finden (zuzüglich Überprüfungen ob die Variable bereits in der zweiten Liste vorhanden ist).

[DNKpp]

Ja, das stimmt schon, nur musst du mit der 1. Methode keine bereits gesetzten variabeln verändern, weswegen das vll doch etwas intuitiever Ist. Aber hast recht, am Ende kommt man auf keine großen Unterschiede, ergo geschmacksache.