Registrierung Kalender Mitgliederliste Teammitglieder Suche Häufig gestellte Fragen Zur Startseite

Informatiker Board » Themengebiete » Praktische Informatik » Algorithmen » Sortierte Felder verschmelzen - Pascal » Hallo Gast [Anmelden|Registrieren]
Letzter Beitrag | Erster ungelesener Beitrag Druckvorschau | An Freund senden | Thema zu Favoriten hinzufügen
Neues Thema erstellen Antwort erstellen
Zum Ende der Seite springen Sortierte Felder verschmelzen - Pascal
Autor
Beitrag « Vorheriges Thema | Nächstes Thema »
s_zzr8ut
unregistriert
Sortierte Felder verschmelzen - Pascal Auf diesen Beitrag antworten Zitatantwort auf diesen Beitrag erstellen Diesen Beitrag editieren/löschen Diesen Beitrag einem Moderator melden       Zum Anfang der Seite springen

Meine Frage:
Hallo zusammen,
ich studiere per Fernstudium Informatik und habe folgende Aufgabenstellung bekommen:

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.

Meine Ideen:
Das ist der Quellcode:

code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
program merge (input, output);
{ liest ohne Eingabeueberpruefung zwei sortierte Felder mit 
  integer-Zahlen ein; beide Felder werden in einem weiteren Feld
  sortiert zusammengefuegt; das Ergebnis wird ausgegeben; ist 
  die Eingabe unsortiert, so ist das Ergebnisfeld undefiniert }
  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 }
i := 0;
j := 0;
k := 0;

while k <> ERGEBNISFELDLAENGE do
  begin
    while Feld1[i+1] <= Feld2[j+1] do
            if i <> FELDLAENGE1 then
          begin
            ErgebnisFeld[k+1] := Feld1[i+1];
            i := i + 1;
            k := k + 1
          end
        else
          begin
            ErgebnisFeld[k+1] := Feld2[j+1];
            j := j + 1;
            k := k + 1
                  end;
    while Feld2[j+1] <= Feld1[i+1] do
        if j <> FELDLAENGE2 then
          begin
            ErgebnisFeld[k+1] := Feld2[j+1];
            j := j + 1;
            k := k + 1
          end
        else
          begin
            ErgebnisFeld[k+1] := Feld1[i+1];
            i := i + 1;
            k := k + 1
          end;
  end; 
  writeln ('Das Ergebnisfeld ist:');  
  for k := 1 to ERGEBNISFELDLAENGE do
    write (ErgebnisFeld[k]:1, ' ');
  writeln
end.


Bis zum Kommentar { Verschmelzungsprozess beginnen } ist alles vorgegeben.
Ich habe einige Varianten getestet, die mit meinem Compiler laufen (Lazarus), aber bei Eingabe auf der Uniwebsite folgende Fehlermeldung ausgeben: "Ihre Einsendung ist fehlerhaft und führt zu einem Programmabsturz zur Laufzeit!
Typische Ursachen sind z.B. Dereferenzierungen von nil oder undefinierten Zeigern.
Z.B. Ein Zugriff der Art zeiger^.next^.info mit zeiger^.next = nil."

Ich weiß mit der Meldung um ehrlich zu sein nichts anzufangen und weiß auch nicht, wo das Problem liegt.

Für jeden hilfreichen Ansatz wäre ich sehr dankbar.

Viele Grüße!
28.04.2018 10:41
as_string as_string ist männlich
Routinier


Dabei seit: 06.11.2013
Beiträge: 495
Herkunft: Heidelberg

Auf diesen Beitrag antworten Zitatantwort auf diesen Beitrag erstellen Diesen Beitrag editieren/löschen Diesen Beitrag einem Moderator melden       Zum Anfang der Seite springen

Ich kann es hier gerade nicht ausprobieren, deshalb nur Vermutungen:
Angenommen in Feld1 existieren Zahlen, die größer sind, als alle Zahlen in Feld2, dann würde Deine innere while-Schleife ihre Bedingung mit einem i+1 außerhalb des Feld1-Arrays überprüfen. Es wird innerhalb der while-Schleife i ja immer hoch gezählt, nachdem überprüft wurde, dass es ungleich der Arraygröße ist. Wenn bei Feld1-Größe von 5 zb i gerade 4 ist, dann würde die if-Bedingung erfüllt werden und i eins hoch gezählt werden. Danach wird aber die Überprüfung in der while-Bedingung ausgeführt, die lautet "while Feld1[i+1] <= Feld2[j+1] ", es wird also auf Feld1[6] zugegriffen.
Allerdings wäre auch j schon eins zu weit zu diesem Zeitpunkt.

Als Lösung: Du musst überhaupt keine while-Schleifen in der äußeren while-Schleife benutzen! Es genügt ein if-else.Im if musst Du aber nicht nur überprüfen, welche nächste Zahl kleiner ist, sondern auch, ob überhaupt noch Zahlen verfügbar sind.
Du gestern also immer nur einen Schritt des Ergebnis-Arrays weiter und schaust: ist in Feld1 noch ein Element vorhanden, dann nimm das, wenn es entweder gar keine Elemente mehr in Feld2 gibt, oder wenn es kleiner ist als das nächste Element in Feld2. Ansonsten nimm das nächste Element von Feld2. Das so lange, bis alle Elemente des Ergebnis-Arrays gefüllt sind.

Gruß
Marco

PS: Allgemein: was ich auch gar nicht verstehe: warum lässt Du alle Zählvariablen von 0 loslaufen und addiert dann überall eine 1? Da ArrayIndizes in Pascal bei 1 los gehen, wäre es dann nicht auch sinnvoller, wenn man die Variablen bei 1 loslassen lässt? Dann muss man allerdings die Überprüfung auf Ende nicht mit i <> Arraygroesse machen, sondern mit while i <= Arraygroesse

PPS: ich würde dann über k auch einfach eine for-Schleife nehmen und keine while.
30.04.2018 10:12 as_string ist offline E-Mail an as_string senden Beiträge von as_string suchen Nehmen Sie as_string in Ihre Freundesliste auf
Baumstruktur | Brettstruktur
Gehe zu:
Neues Thema erstellen Antwort erstellen
Informatiker Board » Themengebiete » Praktische Informatik » Algorithmen » Sortierte Felder verschmelzen - Pascal