Erläutern des Bildes // Code (erstellung)

  • Allgemein

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Erläutern des Bildes // Code (erstellung)

    Guten Tag

    vlt kann mir jemand dieses Bild Interpretieren oder Erläutern

    und kann mir vlt jemand den Code als Ansatz aufschreiben

    Das kann in C++/C+ oder in Delphie geschrieben sein


    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von kLONkRIEGER90 () aus folgendem Grund: Hilfe +Pic

  • Also ansich ist die Aufgabe recht einfach.
    Trotzdem für meinen Geschmack an manchen stellen zu ungenau beschrieben.
    Über welche Datenstrukturen verfügt ihr denn so? Oder befindest du dich in keinem Unterricht sondern hast die Aufgabe nur so aus Interesse vorliegen?
    Code könnte ich dir in den nächsten Stunden in Java liefern.
    Sorry C++ bzw Delphi liegen bei mir schon paar Jahre zurück und da kenn ich auch keine fortgeschrittene Datenstrukturen :)
    Das ganze nur mit Arrays zu machen ist nämlich bisschen aufwendiger :)
    Ansonsten könnt ich dir natürlich auch die Grundidee für ein Programm erklären ;)

  • Meine Lösung in Java. Solltest du noch Erklärungen brauchen, sag einfach bescheid ;)

    Achja die Variante mit der gestrichelten Line ist nicht umgesetzt. Ist aber sehr einfach, statt den Hilfsstapel jedesmal wieder auf den Starstapel zu räumen einfach beim Aufräumen auf Vorschrift vergleichen und falls Treffer direkt auf Ziel verschieben.

    PHP-Quellcode

    1. import java.util.Stack;
    3. public class Main {
    5. /**
    6. * @param args
    7. */
    8. public static void main(String[] args) {
    9. // Für die Vorschrift und den Zielstapel reicht ein einfaches Array
    10. // Möglicherweise ist aber für den Zielstapel auch ein Stack gefordert,
    11. // wegen dem Namen "Stapel"
    12. int vorschrift[] = { 4, 3, 1, 0, 2 };
    13. int ziel[] = new int[5];
    14. // Der Hilfstapel arbeitet nach dem LIFO Prinzip also brauchen wir so
    15. // etwas wie einen Stack (zumindest könnte man das aus der Grafik
    16. // erschliessen)
    17. Stack<Integer> hilfsstapel = new Stack<Integer>();
    18. // Der Startstapel könnte nach LIFO oder FIFO Prinzip arbeiten, der
    19. // Einfachheit halber nehmen wir nochmals LIFO
    20. Stack<Integer> startstapel = new Stack<Integer>();
    21. // Startstapel aufbauen
    22. startstapel.push(4);
    23. startstapel.push(3);
    24. startstapel.push(2);
    25. startstapel.push(1);
    26. startstapel.push(0);
    28. /*
    29. * Durchlaufen der Vorschrift bis zum Ende, ist die Vorschrift
    30. * vollständig abgearbeitet sind wir fertig
    31. */
    32. for (int i = 0; i < vorschrift.length; i++) {
    33. /*
    34. * Jetzt laufen wir durch den Startstapel und vergleichen den Wert
    35. * mit der Vorschrift bei Übereinstimmung verschieben zum
    36. * Zielstapel, andernfalls auf den Hilfstapel
    37. */
    38. while(startstapel.size() > 0){
    39. // Ein Element nach dem anderen vom Starstapel holen
    40. int helper = startstapel.pop();
    41. if (vorschrift[i] == helper) {
    42. // Treffer also verschieben nach ziel
    43. ziel[i] = helper;
    44. } else {
    45. // kein Treffer also verschieben auf den Hilfsstapel
    46. hilfsstapel.push(helper);
    47. }
    48. }
    49. /*
    50. * Möglicherweise befindet sich das nächste gesuchte Element nicht
    51. * mehr im Startstapel sondern bereits im Hilfsstapel, also müssen
    52. * die Elemente wieder in den Startstapel verschoben werden
    53. */
    54. while(hilfsstapel.size() > 0){
    55. // Ein Element nach dem anderen vom Hilfsstapel holen und verschieben
    56. startstapel.push(hilfsstapel.pop());
    57. }
    59. }
    61. // Zur Überprüfung Ausgabe des Ziels
    62. for (Integer ausg : ziel) {
    63. System.out.print(ausg);
    64. System.out.print(",");
    65. }
    67. }
    68. }
    Alles anzeigen

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von stelzi ()

  • Hallo kLONkRIEGER90,

    also ein Lösungsansatz für den ersten Teil (ohne Optimierung = gestrichelte Linie) würde in C++ mit Feldern (Array´s) etwa so aussehen:

    PHP-Quellcode

    1. #include <iostream>
    2. #define MAX_WAGGON 5
    4. using namespace std;
    6. int main(int argc, char **argv)
    7. { // *** Variablen, Zähler, Felder
    8. int itStart, itZiel, itHilfs, itVorschrift;
    9. itStart = itZiel = itHilfs = itVorschrift = 0;
    10. int Vorschrift[] = {4, 3, 1, 0, 2};
    11. int Zielstapel[MAX_WAGGON], Startstapel[MAX_WAGGON], Hilfsstapel[MAX_WAGGON];
    13. // *** Startstapel aufbauen
    14. cout << "Waggon-Nummer:" << endl;
    15. for (int i = 0; i < MAX_WAGGON; i++)
    16. {
    17. Zielstapel[i] = Hilfsstapel[i] = -1;
    18. Startstapel[i] = i;
    19. cout << " -> " << Startstapel[i];
    20. }
    21. cout << endl;
    23. // *** Sortieren ***
    24. do
    25. {
    26. if(Vorschrift[itVorschrift] != Startstapel[itStart])
    27. { // *** Vergleich ohne Treffer
    28. Hilfsstapel[itHilfs] = Startstapel[itStart];
    29. itHilfs++; itStart++;
    30. }
    31. else
    32. { // *** Ansonsten Treffer
    33. Zielstapel[itZiel] = Startstapel[itStart];
    34. itStart++; itZiel++; itVorschrift++;
    35. }
    37. // *** Waggone vom Hilfstapel auf den Startstapel schieben
    38. // *** vom Letzten zum ersten Waggon (LIFO)
    39. if(itStart == MAX_WAGGON)
    40. {
    41. for(int i = itHilfs; i > 0; i--)
    42. Startstapel[i] = Hilfsstapel[i];
    43. itStart = itHilfs = 0;
    44. }
    46. } while (itZiel < MAX_WAGGON);
    48. // *** Ausgabe nach dem Sortieren ***
    49. cout << "\nWaggon-Nummern nach dem sortieren: " << endl;
    50. for (int i = 0; i < MAX_WAGGON; i++)
    51. cout << " -> " << Zielstapel[i];
    52. cout << endl << endl;
    54. system("PAUSE");
    56. return 0;
    57. }
    Alles anzeigen


    Falls Du fragen hast, einfach ne PN!! :)

    Gruß,

    zeroNULL

    Dieser Beitrag wurde bereits 11 mal editiert, zuletzt von zeroNULL ()