Merge-Programm

G

Gast21694

#1
Hallo, ich habe folgende Aufgabe :

Code:
Gesucht ist ein Programm merge, welches zwei (aufsteigend) sortierte Felder von (nicht notwendig verschiedenen) integer-Zahlen zu einem sortierten Feld verschmilzt. Dabei sollen mehrfach vorkommende Elemente auch mehrfach im Ergebnisfeld gespeichert werden. Die beiden Felder werden von der Standardeingabe eingelesen, wobei wir voraussetzen, dass nur sortierte Zahlenfolgen eingegeben werden. Eine Prüfung dieser Annahme ist nicht erforderlich. Das sortierte Ergebnisfeld wird ausgegeben.
Beispiel: Feld1 enthalte die Elemente 11, 14, 18, 80, 100, Feld2 die Elemente 8, 11, 11, 17, 22, 30, 55, 70.
ErgebnisFeld enthält dann nach der Ausführung von merge die Elemente 8, 11, 11, 11, 14, 17, 18, 22, 30, 55, 70, 80, 100, d.h. wenn Feld2 erschöpft ist, müssen noch die restlichen Elemente aus Feld1 nach Feld kopiert werden.

Hinweis: Das Verschmelzen nutzt die bestehende Sortierung des Feldes aus, Sie sollen keinen Sortier-Algorithmus implementieren.
Ein Kopieren der Feldinhalte von Feld1 und Feld2 nach ErgebnisFeld mit anschließendem Sortieren von ErgebnisFeld gilt nicht als Lösung der Aufgabe!
Auch das komplette Kopieren eines Feldes nach ErgebnisFeld mit anschließendem Einsortieren der Elemente des anderen Feldes ist keine Lösung.

Mein Lösungsansatz: Hinweis: Mein Problem liegt zwischen den Kommentaren {Verschmelungsprozess beginnen} und Verschmelzungsprozess beenden}. Frage, warum gibt das Ergebnisfeld nur 13 Nullen aus?

Pascal:
program merge (input, output);

  const
  FELDLAENGE1 = 5;
  FELDLAENGE2 = 8;
  ERGEBNISFELDLAENGE = 13; { FELDLAENGE1 + FELDLAENGE2 }
  
  type
  tFeld1 = array [1..FELDLAENGE1] of integer;
  tFeld2 = array [1..FELDLAENGE2] of integer;
  tErgebnisFeld = array [1..ERGEBNISFELDLAENGE] of integer;

  var
  Feld1 : tFeld1;
  Feld2 : tFeld2;
  ErgebnisFeld : tErgebnisFeld;
  i : integer;
  j : integer;
  k : integer;

begin
  { sortierte Felder einlesen }
  writeln ('Bitte', FELDLAENGE1:2, ' Werte des ersten Feldes ',
  'sortiert eingeben!');
  for i := 1 to FELDLAENGE1 do
  readln (Feld1[i]);
  writeln ('Bitte', FELDLAENGE2:2, ' Werte des zweiten Feldes ',
  'sortiert eingeben!');
  for j := 1 to FELDLAENGE2 do
  readln (Feld2[j]);

  { Verschmelzungsprozess beginnen }
  begin
  k := 1;
  ErgebnisFeld[k]:= Feld1[i] and Feld2[j]
  end;





  { Verschmelzungsprozess beenden }


  writeln ('Das Ergebnisfeld ist:');
  for k := 1 to ERGEBNISFELDLAENGE do
  write (ErgebnisFeld[k], ' ');
  writeln
end.
Viele Grüße
BB
 

Dompteur

Well-Known Member
#2
Die Anweisung in Zeile 36 nimmt das jeweils letzte Feld der beiden Eingabe-Arrays und führt darauf ein bitweises UND aus.
Das Ergebnis dieser Operation wird in das erste Feld des Ergebnis-Arrays geschrieben.

Du sollst aber eigentlich etwas ganz anderes machen.

Du musst eine Schleife über das Ergebnis-Array machen, um für jedes Array-Element den richtigen Wert zuzuweisen.
Um den richtigen Wert zu finden, brauchst du 2 Array-Indizes (z.B.: i1 für Feld1, i2 für Feld2).
Diese beiden zeigen auf das jeweils nächste zu bearbeitenden Element im jeweiligen Array.
Dann vergleichst du Feld1[i1] mit Feld2[i2]. Der kleinere oder bei Gleichheit der erste Wert wird dann ins Zielarray geschrieben.
Dann erhöhst du den Index jenes Arrays, aus dem du den Wert genommen hast.

Zusätzlich muss du noch den Fall behandeln, dass du schon alle Elemente aus einem der beiden Arrays übernommen hast und du nur mehr Elemente aus dem anderen Array zu verarbeiten hast.
 
G

Gast21694

#3
Moin,

danke für deine Antwort! Ich habe es allerdings als Programmier-Neuling noch nicht so ganz verstanden.
Müsste ich die 2 Array-Indizes i1 und i2 dann erst als Variable deklarieren?
Weil, alles vor Zeile 33 und nach Zeile 43 ist fest vorgegeben in der Aufgabe. (Das hatte ich glaub vergessen zu erwähnen, sorry)

Gruß
BB
 
G

Gast21694

#5
Hi,

dann sieht das bei mir so aus:

Code:
 { Verschmelzungsprozess beginnen }
i := 1;
j := 1;
k := 1;
while (i <= FELDLAENGE1) and (j <= FELDLAENGE2) do
if Feld1[i] <= Feld2[j] then
begin
ErgebnisFeld[k] := Feld1[i];
i := i + 1;
k := k + 1
end
else
begin
ErgebnisFeld[k] := Feld2[j];
j := j + 1;
k := k + 1
end;
{ Verschmelzungsprozess beenden }

{ ein Eingabefeld ist abgearbeitet, die restlichen Werte
vom zweiten muessen an Feld angefuegt werden }
if i > FELDLAENGE1 then
repeat
ErgebnisFeld[k] := Feld2[j];
j := j + 1;
k := k + 1;
until k = (ERGEBNISFELDLAENGE+1)
else
repeat
ErgebnisFeld[k] := Feld1[i];
i := i + 1;
k := k + 1;
until k = (ERGEBNISFELDLAENGE+1);
Gruß
BB
 
Oben