2 DynArrays zusammenfuegen

[Lucaito]

Hallo!

Wollt mal fragen wie man 2 dynamische Arrays mit dem Reißverschlussprinzip zusammenfuegt. :/
Hab mich selbst scho probiert, aber irgendwie komm ich noch nich ganz auf die Loesung. xD
Achja, die beiden Arrays haben sehr wahrsch. verschiedene Groessen! Deshalb find ich des recht schwierig...

Danke schonma fuer Antworten, Luca!

[mkinzler]

Wie hast du es versucht? Such mal nach Mischen.

[SirThornberry]

die Frage ist wie du außerhalb der Programmierung 2 mengen im Reisverschlussprinzip zusammenfügst.

Ich würde einmal aus der einen Kiste was nehmen, dann aus der anderen und das solange bis eine Kiste von beiden leer ist. Danach einfach die restlichen Sachen der noch befüllten Kiste hinten anfügen.

In der Programmierung ist es nicht viel anders. Erstmal schauen wieviel Platz man braucht (Anzahl des einen Arrays + Anzahl des zweiten Arrays.
Dann das kleinere Array von beiden durchgehen und die Elemente in jedes zweite Feld des neuen Arrays stopfen (Index * 2)
Danach das größere Array nehmen und bis zur Anzahl des kleinen Arrays die lücken stopfen. Dahinter dann den Rest des größeren Arrays kopieren.

[Scooty78]

versuchs mal so:

Delphi-Quellcode:

 setlength(array3,(length(array1)+length(array2)));

  x := -1;
  for I := 0 to length(array1) - 1 do
    begin
      inc(x);
      array3[x] := array1[i];
      if i <= length(array2)-1 then
      begin
        inc(x);
        array3[x] := array2[i];
      end;
    end;

  if length(array2)> length(array1) then
    begin
      for I := length(array1)-1 to length(array2) - 1 do
        begin
          inc(x);
          array3[x] := array2[i];
        end;
    end;

Gruß
Scooty

[himitsu]

auch will ... auch will ... *hibblig rumhüpf* :firejump:

Delphi-Quellcode:

SetLength(array3, Length(array1) + Length(array2));
z := Min(Length(array1), Length(array2));
x := 0;
For i := 0 to z - 1 do Begin
  array3[x] := array1[i];
  Inc(x);
  array3[x] := array2[i];
  Inc(x);
End;
For i := z to High(array1) do Begin
  array3[x] := array1[i];
  Inc(x);
End;
For i := z to High(array2) do Begin
  array3[x] := array2[i];
  Inc(x);
End;

und in Kurz:

Delphi-Quellcode:

SetLength(array3, Length(array1) + Length(array2));
z := Min(Length(array1), Length(array2));
For i := 0 to z - 1 do Begin
  array3[i * 2]     := array1[i];
  array3[i * 2 + 1] := array2[i];
End;
For i := z to High(array1) do array3[z + i] := array1[i];
For i := z to High(array2) do array3[z + i] := array2[i];

[Neutral General]

-Unsinn-

[Apollonius]

Er will die Arrays nach dem Reißverschlussprinzip zusammenfügen, General.

[himitsu]

@Neutral General:
auch wenn es hier nicht stimmt ... sobald bestimmte Struckturen in dem Array enthalten sind (er hat ja nicht gesagt von welchem Typ sein Array ist), dann kann es damit schöne Speicherprobleme geben

versuch deinen z.B. mal mit Array of String :stupid:
also davor sollte man bei sowas schon warnen :angel:

[Lucaito]

Korrekt, is n Array vom Typ t_inhalt, un t_inhalt wiederum is als type definiert mit string^^

Delphi-Quellcode:

type t_inhalt : string

So, und da mir meine 'liebe' Mutter direkt nachdem ich die Frage geschrieben habe, den WLan-Stick abgenommen hat, musste ich selbst nachdenken. :/
Also 'n Blatt Papier genommen un des mal durchgegangen. ^^
Bin auf ne schicke Lösung ohne 3tes Array gekommen :D

Delphi-Quellcode:

  t := 1;
  for i := 0 to high(schlange2.inhalt) do
    begin
      array_size(inc);
      for j := high(schlange.inhalt) downto t do
        schlange.inhalt[j] := schlange.inhalt[j-1];
      schlange.inhalt[t] := schlange2.inhalt[i];
      t := t+2;
    end;

Trotzdem danke an alle. ^___^

Greetz, Luca

[himitsu]

Also Strings sind Typen, welche initialisiert und finalisiert werden müssen, was bei Move/MoveMemory natürlich nicht der Fall ist.

Zitat:

musste ich selbst nachdenken. :/
Also 'n Blatt Papier genommen un des mal durchgegangen. ^^
Bin auf ne schicke Lösung ... gekommen :D

gut gemacht ^^
und soweit ich das seh, sollte diese auch funktionieren :thumb:

Zitat:

Bin auf ne schicke Lösung ohne 3tes Array gekommen :D

OK, das hattest du nicht gesagt, also daß es auch direkt im Array eingefügt werden soll.

Delphi-Quellcode:

for j := high(schlange.inhalt) downto t do
  schlange.inhalt[j] := schlange.inhalt[j-1];

was man hier noch optimieren könnte, wäre das ständig weiterschieben alle nachfolgenden Einträge

hier werden z.B. erstmal alle Einträge im array1 an ihre neue Position verschoben
und anschließend nur noch die Einträge aus array2 in die entstandenen Freiräume eingefügt.

Delphi-Quellcode:

a := Length(array1);
n := a + Length(array2);
z := Min(a, Length(array2));
SetLength(array1, n);
For i := a - 1 downto z do array1[z + i] := array1[i];
For i := z - 1 downto 1 do array1[i * 2] := array1[i];
For i := 0 to z - 1 do array1[i * 2 + 1] := array2[i];
For i := z to High(array2) do array1[z + i] := array2[i];

für das Verständnis:
die 1. Schleife verschiebt alles, was zusammenhängend von array1 am Ende des gemeinsamen Arrays steht (falls vorhanden).
die 2. Schleife verschiebt die Elemente im gemeinsamen Anteil.
die 3. Schleife fügt die Elemente von array2 in den gemeinsamen Anteil.
die 4. Schleife hängt die übrigen Teile an, welche nach dem gemeinsamen Teil liegen (falls vorhanden).

im gemeinsamen Teil sind die Einträge dann nach dem Reisverschlußprinzip verteilt.