weiter unten im Forum hatte ich einen Thread bezüglich MySQL aufgemacht. Leider ist das tragbare Volumen einer MySQL Datenbank nicht gegeben. Als Oracle-DBA würde ich gerne Oracle einsetzen, aber leider wären mir die Kosten zu hoch und andere Datenbanken - ausser MySQL - haben nicht die Power, die ich mit "selbstgebastelten Code" erreichen kann.

Oh, hab ich grad gelesen.
ob du aber mit meinem Beispiel 4,5 GB Daten sortieren kannst wage ich zu bezweifeln.

Struppi.

Tag jonny.

wauh ... das ist harter Tobak! Da werde ich wohl hart durchkämpfen müssen!

Och, so schlimm ist es nun auch wieder nicht, ich habe auch nur ca. 2 Lichtjahre gebraucht, bis ich es kapiert hatte ;-)

Ich möchte dir gerne mal zeigen, was ich mir vorgestellt hatte und fände es klasse, wenn du es mal bewerten könntest.

Letztendlich machst du auch nichts anderes als der von mir gepostete Vorschlag, nur nicht mit einer temporären Liste, sondern mit mehreren Arrays.

Folgendes Beispiel:
es soll nach Spalte 2 sortiert werden
my $c=2;
[...]
my $s=0;
[...]
while(<FILE>) {
   my @tmp=split / /,$_;
   $tmp[$t]="$tmp[$t]n$t";  #n$t als Index

Das soll doch hier sicher $tmp[$c] = "$tmp[$c]n$s"; heißen, oder? Der Rest sieht so okay aus, wenngleich es mir sehr umständlich erscheint :-)

Siechfred

Hallo,

my $c=2;
my @data0;
my @data1;
my @data2;
my @data3;
my @data4;
my @data5;
my $s=0;

while(<FILE>) {
   my @tmp=split / /,$_;
   $tmp[$t]="$tmp[$t]n$t";  #n$t als Index
   $data0[$s]=$tmp[0];
   $data1[$s]=$tmp[1];
   $data2[$s]=$tmp[2];
   $data3[$s]=$tmp[3];
   $data4[$s]=$tmp[4];
   $data5[$s]=$tmp[5];
   $s++;
}

Du solltest Dir unbedingt einmal http://www.perldoc.com/perl5.8.4/pod/perldsc.html bzw. http://www.perldoc.com/perl5.8.4/pod/perllol.html

Dann würde das ungefähr so aussehen (kann aber durchaus auhc abegwandelt werden;-)

my $c=2;
my @data;

while(<FILE>) {
    my @tmp=split / /,$_;
    $tmp[$t]="$tmp[$t]n$t";  #n$t als Index
    for($col = 0; $col<6;$col++) {
       $data[$col][$s]=$tmp[$col];
       }
    $s++;
    }

Und der Rest ist dann auch einfacher. Aber lies selbst.

Grüße
  Klaus

Tag jonny.

In $_ steht jede volle Zeile aus @zeilen, so wie es auch bei einem normalen Schleifendurchgang der Fall ist "while(<>) {}" und es werden anonyme Arrays gebildet [], genau genommen zwei, nämlich $a->[0] und $a->[1].

Ich habe es mir bildlich als ein anonymes mehrdimensionales Array vorgestellt, also ein Array, dessen Elemente wiederum Arrays sind. Ich nehme mal die ersten zwei Zeilen aus deinem Ausgangsposting:

Spalte 0   1    2    3  4  5
----------------------------
20041215  2.3 812.2 48 32 20
20041215 31.9  12.2 34 12 54

Das letzte map macht daraus quasi ein anonymes mehrdimensionales Array:

diesen Teil nenne ich »Elementarray«
           ----------------------------------------------
Liste[0] = [ Array[ Zeile 1, Spalte Nr. 3 aus Zeile 1 ] ]
         = [ "20041215 2.3 812.2 48 32 20", "48" ]
Liste[1] = [ Array[ Zeile 2, Spalte Nr. 3 aus Zeile 2 ] ]
         = [ "20041215 31.9 12.2 34 12 54", "34" ]

$a->[0] ist das erste Element des Elementarrays und hat die gesamte Zeile als Inhalt ($_), $a->[1] ist das zweite und hat nur das gesuchte Feld als Inhalt. Man könnte es auch so schreiben:

$Liste[0][0] entspricht $a->[0] entspricht $_
$Liste[0][1] entspricht $a->[1] entspricht dem Ergebnis der split-Anweisung

Die Reihenfolge, in der die Elemente im Elementarray abgelegt werden, bestimmt die map-Anweisung.

In $a->[0] befindet sich der Inhalt ausser $nr.

Nein, die _komplette_ Zeile (repräsentiert durch $_), wie du oben siehst.

In in $a->[1] befindet sich der Inhalt der split $nr Operation, also die Spalte, die ich sortieren möchte. Mit der Sortierung in $a->[1] wird auch die Reihenfolge der Zeilen in In $a->[0] angepasst.

Genau, denn sortiert wird nicht das Elementarray »Array«, sondern »Liste«, Sortierkriterium ist dabei das zweite Element von »Array«, deshalb $a->[1].

wie du schon schriebst, wird hier das Ergebnis der Sortierung wieder an $_ zurückgegeben, also die sortierte Spalte wird wieder an ihre position gebracht.

Die anonyme Liste wird quasi aufgelöst, sodass am Ende vom nunmehr sortierten mehrdimensionalen anonymen Array nur ein einfacher Array »@sortiert« übrig bleibt, dessen Elemente jeweils eine vollständige Zeile enthalten, sortiert nach Spalte 3. $a->[1] wurde nur für die Sortierung benötigt und wird durch die obere map-Anweisung sozusagen eliminiert, da es nicht mehr gebraucht wird. Da diese map-Anweisung auf alle Listenelemente angewandt werden soll, muss die Liste Element für Element durchgegangen werden, deshalb kommt hier die vordefinierte Variable $_ (das jeweils aktuelle Element) zur Anwendung.

Ich hoffe, dass ich mich einigermaßen verständlich ausgedrückt habe :-)

Siechfred

Hallo jonny

Hallo Siechfred,

jetzt starre ich nun schon seit ca. 1 1/2 Stunden auf diese drei Zeilen Code und versuche wirklich es zu verstehen.

@sortiert = map  { $_->[0] }                                #1
            sort { $a->[1] <=> $b->[1] }                    #2
            map  { [ $_, (split / /)[$nr] ] } @zeilen;      #3

Ich habe es folgendermaßen verstanden...

zu 3.
In $_ steht jede volle Zeile aus @zeilen, so wie es auch bei einem normalen Schleifendurchgang der Fall ist "while(<>) {}" und es werden anonyme Arrays gebildet [], genau genommen zwei, nämlich $a->[0] und $a->[1].

Nein, ein Array. Index [0] ist die Zeile und [1] ist die Spalten nach der du sortieren willst.
(es ist übrigens eher eine foreach Schleife als while)

zu 2.
In $a->[0] befindet sich der Inhalt ausser $nr. In in $a->[1] befindet sich der Inhalt der split $nr Operation, also die Spalte, die ich sortieren möchte. Mit der Sortierung in $a->[1] wird auch die Reihenfolge der Zeilen in In $a->[0] angepasst.

In $a->[0] und $b->[0] ist jeweils die komplette Zeile. In [1] ist die Spalte, richtig. Mit 2.) wird das Array (mit den anonymen Array als einträge) das in 1.) (mit dem map) erzeugt wird sortiert.

zu 1.
wie du schon schriebst, wird hier das Ergebnis der Sortierung wieder an $_ zurückgegeben, also die sortierte Spalte wird wieder an ihre position gebracht.

Nein, es werden die ursprüngliche Zeilen sortiert nach n zurückgegeben.

Das ganze ist ungefähr das gleiche wie ich dir hier schon schrieb https://forum.selfhtml.org/?t=99696&m=609398 wobei das von mir aber ein bisschen verständlicher ist als die Schwartzschen Transformation, wie ich finde.

Struppi.

Tag Konrad.

Würde die o.g. Transformation auch in Javascript funktionieren? (Ich bin allerdings nicht sicher, ob es da anomyme Arrays gibt)

Naja, es dürfte m.E. ziemlich schwierig sein, die Schwartzsche Transformation in Javascript umzusetzen. Prinzipiell kann man allerdings Array.sort auch auf mehrdimensionale Arrays anwenden:

<script  type="text/javascript">
<!--
function Numsort(a,b)
{ return a[nr]-b[nr]; }

var Namen = new Array();
// Name des Dichters, Geburtsjahr, Sterbejahr, Alter
Namen[0] = ["Friedrich Schiller",1759,1805,46];
Namen[1] = ["Johann Wolfgang Goethe",1749,1832,83];
Namen[2] = ["Bettina von Arnim",1785,1859,74];
Namen[3] = ["Clemens Brentano",1778,1842,64];

var nr=1;
Namen.sort(Numsort);
Namenausgabe = Namen.join("<br>");
document.write("<p>Nach Geburtsjahr sortierte Namen:<br>" + Namenausgabe + "</p>");

var nr=2;
Namen.sort(Numsort);
Namenausgabe = Namen.join("<br>");
document.write("<p>Nach Sterbejahr sortierte Namen:<br>" + Namenausgabe + "</p>");

var nr=3;
Namen.sort(Numsort);
Namenausgabe = Namen.join("<br>");
document.write("<p>Nach erreichtem Lebensalter sortierte Namen:<br>" + Namenausgabe + "</p>");

//-->
</script>

Allerdings funktioniert das mit Numsort nur bei Zahlen, nicht aber bei Strings, die nicht nur aus Zahlen bestehen. Würde man in meinem obigen Beispiel Numsort auf Spalte 0 anwenden, führt das nicht zu einem brauchbaren Ergebnis.

Siechfred