Frage zu Informatik Programm

Status
Nicht offen für weitere Antworten.
B

bladerama

Gast
Hi Leute!

http://www.zaik.uni-koeln.de/AFS/teachings/courses/Info1/uebungen/progaufg1.pdf
Das ist folgende Aufgabe die ich zu bearbeiten habe. Es geht bei meiner Frage aber nur um die Struktur, nicht um die Loesung dieser Aufgabe.


Habe mich erst mal mit dem Einlesen der Daten Zeilenweise aus einer Textdatei beschaeftigt.
Dieser Code laeuft auch soweit.
Nur soll ich ja nach Aufgabenstellung eine gesonderte Struktur benutzen.

Das soll ich fuer das Einlesen benutzen laut Aufgabenstellung:
public Einlesen (string dateiname, int position)

Ist das nun eine Methode?
Habe versucht meine Code schon als Methode umzuschreiben. Aber leider ist mir das nicht gelungen.
Ich bin noch neu im Java Programmieren. Mir macht die Syntax noch ein wenig Probleme.

Hier ist mal mein derzeitiger Code:

Code:
import java.io.*;

class Einlesen
{
  public static void main ( String[] args ) throws IOException
   {
	BufferedReader in = new BufferedReader(new FileReader("Polynom.txt"));
	String zeile = null;
	int i = 1;
	String hoechsterexpo = in.readLine();
	int inthoechsterexpo = Integer.parseInt(hoechsterexpo);
	int[] a = new int[inthoechsterexpo + 2];
	a[0] = inthoechsterexpo;
	while ((zeile = in.readLine()) != null) 
	{
	int zahl = Integer.parseInt(zeile);
	a[i] = zahl;
	i++;
	}
	for (int j = 0; j <= inthoechsterexpo + 1; j++)
	System.out.println(a[j]);
	
   }
}


Wie mache ich daraus eine Methode?

Code:
class Einlesen 
{
public Einlesen (string dateiname, int position)
{
        Dateiname = "Polynom.txt";
	BufferedReader in = new BufferedReader(new FileReader(Dateiname));
	String zeile = null;
	int i = 1;
	String hoechsterexpo = in.readLine();
	int inthoechsterexpo = Integer.parseInt(hoechsterexpo);
	int[] a = new int[inthoechsterexpo + 2];
	a[0] = inthoechsterexpo;
	while ((zeile = in.readLine()) != null) 
	{
	int zahl = Integer.parseInt(zeile);
	a[i] = zahl;
	i++;
	}
	for (int j = 0; j <= inthoechsterexpo + 1; j++)
	System.out.println(a[j]);
	
   }
}

Wo und welche return-Anweisung muss ich denn nun setzen? Damit ich von "main" wieder das Array ausgeben lassen kann?

danke

[Edit by Beni: Codetags]
 

Niki

Top Contributor
Das ist keine Methode, sondern ein Konstruktor. (dieser wird jedes mal beim erzeugen eines Objekts dieser Klasse aufgerufen, dient sozusagen zum initialisieren).
Aufrufen kannst du das ganze so aus der main-Methode.
Code:
Eingabe e = new Eingabe();
 
B

Beni

Gast
Und so wie es in der Aufgabenstellung steht, ist es schlicht und einfach falsch. Vermutlich sollte da "public void Einlesen(..." stehen.
 

ARadauer

Top Contributor
ich finde es sehr bedänklich wenn Uni Proffesoren Methoden groß schreiben.
Wie soll man erwarten, dass sich Schüler an die Kodekonventionen halten, wenn es nicht mal die Profs machen......
 

bladerama

Mitglied
Hallo, danke erst mal für die schnellen antworten.

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/


Code:
import java.io.*;

class einlesen1
{
  public void Ein(String dateiname, int position) throws FileNotFoundException, IOException
  {
  dateiname = "Polynom.txt";
  BufferedReader in = new BufferedReader(new FileReader(dateiname));
  String zeile = null;
  int i = 1;
  String hoechsterexpo = in.readLine();
  int inthoechsterexpo = Integer.parseInt(hoechsterexpo);
  int[] a = new int[inthoechsterexpo + 2];
  a[0] = inthoechsterexpo;
  while ((zeile = in.readLine()) != null)
  {
  int zahl = Integer.parseInt(zeile);
  a[i] = zahl;
  i++;
  }
  for (int j = 0; j <= inthoechsterexpo + 1; j++)
  System.out.println(a[j]);

  }
  
  public static void main ( String[] args ) throws IOException
   {
  
 einlesen1 e = new einlesen1();
    
  
   }
}


Müsste der Code dann so aussehen? Kompilieren kann ich ihn jedenfalls so.
Wie kann ich denn nun das Array wieder direkt aus der Main-Mehode ausgeben lassen? Der Aufruf so alleine reicht nicht?
Komme mit der Syntax von Java noch nicht so gut zurecht.

PS: Sorry das ich eben die Code-Brackets vergessen habe.
 

Marco13

Top Contributor
Wie Beni schon gesagt hat: Die Aufgabenstellung ist schlicht und einfach syntaktisch falsch. (Die einzige Rechtfertigung dafür könnte sein, dass es Teil der Aufgabe ist, zu lernen, so weit zu verstehen, was man da macht, dass man in der Lage ist, zu erkennen, DASS die Vorgabe falsch ist).

Das "Einlesen" sollte eine Methode in der Klasse Polynom sein.
Code:
class Polynom 
{
    Monom head;
    Monom laufzeiger;

    ....

    public void Einlesen (string dateiname, int position)
    {
        // Hier den code einfügen, den du in deiner Klasse in der Methode "Ein" stehen hast -
        // leicht abgewandelt, so dass "this" danach die eingelesenen Daten enthält

       // PSEUDO(!)code: 
       this.head = liesDasErsteMonomAusDerDatei();
       while (...)
       {
           ...
            this.laufzeiger.nechster = liesDasNächsteMonom()....
            ....
       }
    }
}

Das soll man später wohl so verwenden können
Code:
Polynom polynom = new Polynom();
polynom.Einlesen("datei.txt", 123);
 

bladerama

Mitglied
Code:
polynom.Einlesen("datei.txt", 123);

dazu habe ich noch mal ne Frage. Ich will doch eigentlich das ganze Polynom auf einmal einlesen und gleichzeitig die eingelesenen Daten auf die Liste verteilen...

Ich verstehe den code oben nun so, dass ich aus der Datei "datei.txt" die Position ( Zeile ) 123 auslese.
Wie versteht ihr das denn aus der Aufgabestellung? Steht das gesamte Polynom nun mit leerzeichen in einer Zeile, oder in einer Datei abwaerts Zeilenweise pro Koeffizient?


Irgendwie bekomme ich das ganze Programm so nicht zum laufen.

Code:
class Monom                  //-Das einzelne Polynomnglied
{                                   // wird als "Monom" bezeichnet...

  public Monom naechster;    //-Der Zeiger auf den nächsten Monom...
  public int koeffizient;      //-Die Daten des Monoms. Da es sich hierbei
  public int exponent;                              // um eine Referenz auf eine Variable vom Typ
                              // Object handelt und Objekte in der Daten-
                              // hierarchie von Java an aller erster
                              // Stelle stehen, kann JEDES beliebige Objekt
                              // JEDER beliebigen Klasse gespeichert werden.
                              // Es ist also sogar möglich, eine verkettete
                              // Liste in einer anderen zu verwenden...

  public Monom(int koe, int exp)     //-Der Konstruktor von Monom lässt koeffizient und exponent
  {                                               // auf das Objekt zeigen, welches
	  koeffizient = koe;            // dem Monom zugewiesen sein soll...
	  exponent = exp;
  }
}

class Polynom                                 //-Die endgültige verkettete Liste, die dem
{                                           // Benutzer die nötigen Methoden bereitstellt,
                                            // um seiner instanzierten Liste neue Monom
                                            // hinzuzufügen oder zu entfernen...
  
  public Monom head = new Monom(1,5);       //-Der kopf und auch das ende
  public Monom ende = new Monom(2,4);       // der Liste werden bereits zu
  public Monom laufzeiger;                                          // Beginn instanziert, damit
                                            // ohne einen NullPointerAssignment-
                                              // Fehler auszulösen...

  public Polynom()                            //-Der Konstruktor von Polynom erstellt eine
  {                                         // Liste, deren kopf zu Beginn auf das ende
    head.naechster = ende;                  // zeigt, welches wiederum auf null zeigt.
    ende.naechster = null;                  // (Unter null versteht man einen Nullpointer;
  }                                         // er zeigt auf keinerlei Adressen im Speicher.)


  public void Ausgeben()
  {
    Monom aktMonom = head;                    //-Die Variable aktMonom ist
                                                      // die Laufvariable, die zu
                                                      // Beginn auf kopf zeigen soll...

    while (aktMonom != null)              //-Jedes Monom der Liste wird der
                                                      // Reihe nach abgelaufen, bis das
                                                      // Ende der Liste erreicht ist...
    {
	    System.out.println("Koeffizient lautet: " + aktMonom.koeffizient + " Exponent lautet: " + aktMonom.exponent);    //-Von jedem erreichten Monom wird
                                                      // das Element ausgegeben...

      aktMonom = aktMonom.naechster;                  //-Und dann aktMonom auf den
    }                                                                        // Nachfolger des aktuellen Monoms
  }                                                                          // (also einen Monom weiter in der
}                                                                            // Liste) gesetzt...
public class Poly
{
  public static void main(String[] params)
  {
    Polynom liste = new Polynom ();
    liste.Ausgeben();



  }
}

das ist so das was ich bis jetzt zustande gebracht habe... Daran orientiere ich mich zur Zeit.
Jedoch schaffe ich es nicht das ganze in ein Gefuege zu bringen. Kann mir da vllt noch mal jemand ein paar Tipps geben?



greetz
 

Marco13

Top Contributor
Man braucht den Head nicht zu initializiseren. Und ein 'ende' braucht man (glaubich) auch nicht. Das Format der Eingabedatei würde ich so interpretieren

4
5
3
6
0
7
5

7


Wenn man dort nun von Zeile 2 an lesen soll, dann steht da erstmal die 3. D.h. das Polynomn hat die Form nx^3 + ...
Die Nachfolgenden 4 Zeilen geben die Koeffizienten an, d.h. das Polynom, das man hieraus mit
polynom.einlesen(eingabeDateiName, 2);
lesen würde, wäre
6x^3 + 0x^2 + 7x^1 + 5x^0
 

bladerama

Mitglied
d..h. java liesst die erste Zeile der TextDatei also Zeile 0 ?
Wie kann ich java denn dazu bringen, Zeilen auszulassen?

oder behelfe ich mir nun mit:

for (int i =0; i < position; i++)
in.readLine();

?
Also in.readLine() liesst ja dann schon zeilen ein die aber dann nicht verwendet werden bis zu der Zeile ab der man dann wirklich einlesen will...
 

Niki

Top Contributor
Was spricht dagegen alle Zeilen zuerst einzulesen und dann in einer Datenstruktur (z.b. List<String>) zu halten. Du brauchst dann in der Methode nur noch in die Liste rein schaun. So wird so etwas auch normalerweise gemacht.
 

Marco13

Top Contributor
Natürlich würde man das in der Praxis nicht so machen. Es geht hier aber nicht um den Entwurf einer marktreifen Business-Anwendung mit Multi-Tier-Architektur, sondern um ein Furzprogramm, an dem man sehen soll, welcher Student sich bei so einer Implementierung einer elementaren Datenstruktur wie einer verketteten Liste am wenigsten dämlich anstellt. Oder anders gesagt: "The Master" macht eine Vorgabe, wie die Schnittstellen auszusehen haben (hier der Prof, in der Praxis der Kunde oder Chef) und man muss das beste daraus machen. Abgesehen davon ... stell dir vor es gibt 200 Studenten, und jeder schreibt so ein Programm mit "seinen" Methoden und Strukturen ... Man muss ... zumindest in Erwägung ziehen.... dass das ganze automatisiert getestet wird - aufgrund der GENAUEN Spezifikation der geforderten Ausgabe (ganz am Ende) muss man sogar schon fast davon ausgehen...
 

Niki

Top Contributor
Da hast du wohl recht, jedoch finde ich dass der Prof. dann die Angabe überarbeiten sollte. Er kann vorgeben dass es eine Methode zum Erzeugen der Dateiinhalte geben soll. Natürlich müsste dann der automatisierte Test auch angepasst werden, das ist natürlich mit Arbeit verbunden.
 

bladerama

Mitglied
Code:
package einlesen;

import java.io.*;
class einlesen
        
{
  public void ein(String dateiname, int position) throws FileNotFoundException, IOException
    {
     BufferedReader in = new BufferedReader(new FileReader("Polynom.txt"));
     String zeile = null;
     int i = 1;
     String hoechsterexpo = in.readLine();
     int inthoechsterexpo = Integer.parseInt(hoechsterexpo);
     int[] a = new int[inthoechsterexpo + 2];
     a[0] = inthoechsterexpo;
     while ((zeile = in.readLine()) != null)
     {
     int zahl = Integer.parseInt(zeile);
     a[i] = zahl;
     i++;
     }
    for (int j = 0; j <= inthoechsterexpo + 1; j++)
    System.out.println(a[j]);
   }
    
  public static void main ( String[] args ) throws IOException
   {
   einlesen polynom = new einlesen();
   polynom.ein("Polynom.txt", 1);
   }
}

Wieso läuft das denn nun so nicht mehr? Ich blicke überhaupt nicht mehr durch. Das müsste doch einfach ein ganz normaler Methodenaufruf sein...

btw: ( mir ist schon klar das ich die übergebenen Variablen nicht benutze ).
 

bladerama

Mitglied
Eigentlich sollten die eingelesenen Daten ja wieder ausgegeben werden... zu dem schreibt er, er findet die Datei nicht.
Wenn der Code aber so in der main methode steht ist alles ok. Und die Datei Polynom.txt ist auch an ihrem richtigen platz.
 

bladerama

Mitglied
oh man das lag an der Package Anweisung von Netbeans. ohne diese läuft es bei mir ohne probleme !

danke noch mal
 

bladerama

Mitglied
Code:
import java.io.*;
class einlesen

{
  public void ein(String dateiname, int position) throws FileNotFoundException, IOException
    {
     BufferedReader in = new BufferedReader(new FileReader("Polynom.txt"));

     //Durchrücken der Zeilen der Datei damit bei der richtigen Datei angefangen wird einzulesen
     for (int k = 1;k < position;k++)
     {
       in.readLine();
     }
     String zeile;                                                               // Hilfsvariable um den
     String hoechsterexpo = in.readLine();                                       // Hoechsten Exponenten einlesen
     int inthoechsterexpo = Integer.parseInt(hoechsterexpo);                     // String in int umwandeln

     int[] a = new int[inthoechsterexpo + 2];                                    // Array inzinieren
     a[0] = inthoechsterexpo;                                                    // Hoechstenexponent ins Array eintragen

     // Einlesen der Polynomglieder in Arrays
     for (int i = 1; i <= inthoechsterexpo; i++)
     {
      zeile = in.readLine();                                                     //Einlesen der Zeile
      int zahl = Integer.parseInt(zeile);                                        //String in int umwandeln
      a[i] = zahl;                                                               //Int zahl in array speichern
     }


    for (int j = 0; j <= inthoechsterexpo + 1; j++)                              //Zwischenausgabe zum Überprüfen
    System.out.println(a[j]);
   }

  public static void main ( String[] args ) throws IOException
   {
   einlesen polynom = new einlesen();
   polynom.ein("Polynom.txt",3);
   }
}

Ihr glaubt gar nicht wie froh ich bin, dass nun endlich mal diese Einlesemethode läuft!!! Habe echt schon an mir gezweifelt!

Kann mir bitte noch mal jemand helfen, wie ich nun die eingelesenen Arraydaten auf die Knoten verteile?
Also meine frage ist im Endeffekt, wie kann ich nun diese Daten an die Einfuegen(Monom P) Methode übertragen?

danke!!!!
 

bladerama

Mitglied
Code:
import java.io.*;
class Monom                  //-Das einzelne Polynomnglied
{                             // wird als "Monom" bezeichnet...

  public Monom naechster;    //-Der Zeiger auf den nächsten Monom...
  public int koeff;
  public int exp;      //-Die Daten des Monoms. Da es sich hierbei
                              // um eine Referenz auf eine Variable vom Typ

  public Monom(int k, int e)   //-Der Konstruktor von Monom lässt element
  {                           // auf das Objekt zeigen, welches
    koeff = k;            // dem Monom zugewiesen sein soll...
    exp = e;
  }

  public static void main(String[] params)throws IOException{

    Polynom liste = new Polynom ();
    liste.Einlesen("Polynom.txt",2);
    liste.Einfuegen(2,1);
    liste.ausgeben();

  }
}

class Polynom                               //-Die endgültige verPolynomte Liste, die dem
{                                           // Benutzer die nötigen Methoden bereitstellt,
public Monom head;
public Monom ende;
public Monom laufzeiger;

  public void Einfuegen(int koeff, int exp) {


  }

  public void Einlesen(String dateiname, int position) throws FileNotFoundException, IOException
    {
      BufferedReader in = new BufferedReader(new FileReader("Polynom.txt"));

     //Durchrücken der Zeilen der Datei damit bei der richtigen Datei angefangen wird einzulesen
     for (int k = 1;k < position;k++)
     {
       in.readLine();
     }
       String zeile;                                                               // Hilfsvariable um den
       String hoechsterexpo = in.readLine();                                       // Hoechsten Exponenten einlesen
       int h = Integer.parseInt(hoechsterexpo);                     // String in int umwandeln
       if (h < 0 )
       System.out.println("Fehler hoechster Exponent negativ");
       else
       {


       int[] a = new int[h + 2];                                    // Array inzinieren
       a[0] = h;                                                    // Hoechstenexponent ins Array eintragen

     // Einlesen der Polynomglieder in Arrays
        for (int i = 1; i <= h + 1; i++)
     {
        zeile = in.readLine();                                                     //Einlesen der Zeile
        int zahl = Integer.parseInt(zeile);                                        //String in int umwandeln
        a[i] = zahl;                                                               //Int zahl in array speichern
     }

        this.head = new Monom(h,0);                              // Kopf der Kette
        this.ende = new Monom(a[h+1],0);                         // Ende der Liste
        head.naechster= ende;
        ende.naechster= null;


     for (int j = h; j >= 1;j--)
     {
      Monom neuKnoten = new Monom(a[j],h - j + 1);
      neuKnoten.naechster  = head.naechster;
      head.naechster = neuKnoten;
     }




    }
   }




  public void ausgeben()
  {
    Monom aktuellerMonom = head;                    //-Die Variable aktuellerMonom ist

    while (aktuellerMonom != null)                   //-Jeder Monom der Liste wird der
                                                // Ende der Liste erreicht ist...
    {
      System.out.print(aktuellerMonom.koeff + " ");    //-Von jedem erreichten Monom wird
                                                   // das Element ausgegeben...

      aktuellerMonom = aktuellerMonom.naechster;    //-Und dann aktuellerMonom auf den
    }                                                 // Nachfolger des aktuellen Monoms
  }                                                   // (also einen Monom weiter in der
}                                                     // Liste) gesetzt...



Fragen: Wofür brauche ich eigentlich den Monom laufzeiger ?!
Und wie soll
public void Einfuegen(Monom P) funktionieren, ich meine dieses Monom P. Das müsste doch wieder int koeff, int exp sein?!
public void Einfuegen(int koeff, int exp) sollte das dann so aussehen?!
 

Niki

Top Contributor
der Laufzeiger zeigt auf das zuletzt eingefügt Monom. Wenn du jetzt ein neues Monom hinzufügst sagst du:
Code:
laufzeiger.setNext(neuesMonom);
laufzeiger = neuesMonom;

EDIT, natürlich noch vorher überprüfen, ob der laufzeiger nicht null ist (was er ja am Anfang ist)

Code:
//erstes Monom
if(laufzeiger == null){
  start = neuesMonom;
  laufzeiger = neuesMonom;
} else {
  laufzeiger.setNext(neuesMonom);
  laufzeiger = neuesMonom;
}
 

bladerama

Mitglied
Guten Morgen

und danke für die Antwort!

Code:
import java.io.*;
class Monom                  //-Das einzelne Polynomnglied
{                             // wird als "Monom" bezeichnet...
  Monom naechster;    //-Der Zeiger auf den nächsten Monom...
  int koeff;
  int exp;      //-Die Daten des Monoms. Da es sich hierbei
                              // um eine Referenz auf eine Variable vom Typ int handelt

  Monom(int k, int e)     //-Der Konstruktor von Monom lässt element
  {                       // auf das Objekt zeigen, welches
    koeff = k;            // dem Monom zugewiesen sein soll...
    exp = e;
  }

  public static void main(String[] params)throws IOException{

    Polynom liste = new Polynom ();
    Polynom liste2 = new Polynom ();
    liste2.Einlesen("Polynom.txt",1);
    liste.Einlesen("Polynom.txt",2);

    //Monom p = new Monom(5,1);
    //liste.Einfuegen(p);
    //liste.Loeschen(p);
    liste.ausgeben();
    System.out.println();
    liste2.ausgeben();
  }
}

class Polynom                               //-Die endgültige verPolynomte Liste, die dem
{                                           // Benutzer die nötigen Methoden bereitstellt,
public Monom head;
public Monom ende;
public Monom laufzeiger;
public Monom p;

  public void Einfuegen(Monom p)
  {
      int hdiff;
      hdiff = (p.exp - head.koeff);

      if (p.exp > head.koeff)
        {
          head.koeff = p.exp;
          for (int j = hdiff; j > 1;j--)
          {
              Monom neuKnoten = new Monom(0,p.exp - j);
              neuKnoten.naechster  = head.naechster;
              head.naechster = neuKnoten;
          }
              Monom neuKnoten = new Monom(p.koeff,p.exp);
              neuKnoten.naechster  = head.naechster;
              head.naechster = neuKnoten;
         }
      else
      {
          Monom aktuellerKnoten = head.naechster;                    //Lassen den Kopf direkt aus!

       while (aktuellerKnoten != null)                   //-Jeder Knoten der Liste wird der
          {
            if ( aktuellerKnoten.exp == p.exp )
            {
              aktuellerKnoten.koeff += p.koeff;
              return;
            }
            
            aktuellerKnoten = aktuellerKnoten.naechster;    //-Und dann aktuellerKnoten auf den
          }                                                 // Nachfolger des aktuellen Knotens
       }                                                   // (also einen Knoten weiter i

   }

   public void Loeschen(Monom p)
   {
    Monom aktuellerKnoten = head.naechster;                     // Der Kopf wird direkt ausgelassen.
    while (aktuellerKnoten != null)                   //-Jeder Knoten der Liste wird der
          {
            if ( aktuellerKnoten.exp == p.exp )
            {
              aktuellerKnoten.koeff = 0;              //Koeffzient wird auf 0 gesetzt. ( gelöscht ) !
              return;
            }

            aktuellerKnoten = aktuellerKnoten.naechster;    //-Und dann aktuellerKnoten auf den
          }
   }
   

  public void Einlesen(String dateiname, int position) throws FileNotFoundException, IOException
    {
      BufferedReader in = new BufferedReader(new FileReader("Polynom.txt"));

     //Durchrücken der Zeilen der Datei damit bei der richtigen Datei angefangen wird einzulesen
     for (int k = 1;k < position;k++)
     {
       in.readLine();
     }
       String zeile;                                                // Hilfsvariable um den
       String hoechsterexpo = in.readLine();                        // Hoechsten Exponenten einlesen
       int h = Integer.parseInt(hoechsterexpo);                     // String in int umwandeln
       if (h < 0 )
       System.out.println("Fehler hoechster Exponent negativ");
       else
       {

       int[] a = new int[h + 2];                                    // Array inzinieren
       a[0] = h;                                                    // Hoechstenexponent ins Array eintragen

     // Einlesen der Polynomglieder in Arrays
        for (int i = 1; i <= h + 1; i++)
     {
        zeile = in.readLine();                                                     //Einlesen der Zeile
        int zahl = Integer.parseInt(zeile);                                        //String in int umwandeln
        a[i] = zahl;                                                               //Int zahl in array speichern
     }

        this.head = new Monom(h,0);                              // Kopf der Kette
        this.ende = new Monom(a[h+1],0);                         // Ende der Liste
        head.naechster= ende;
        ende.naechster= null;


     for (int j = h; j >= 1;j--)
     {
      Monom neuKnoten = new Monom(a[j],h - j + 1);
      neuKnoten.naechster  = head.naechster;
      head.naechster = neuKnoten;
     }
    }
   }
public void ausgeben()
  {
    Monom aktuellerMonom = head;                    //-Die Variable aktuellerMonom ist

    while (aktuellerMonom != null)                   //-Jeder Monom der Liste wird der
                                                // Ende der Liste erreicht ist...
    {
      System.out.print(aktuellerMonom.koeff + " ");    //-Von jedem erreichten Monom wird
                                                   // das Element ausgegeben...

      aktuellerMonom = aktuellerMonom.naechster;    //-Und dann aktuellerMonom auf den
    }                                                 // Nachfolger des aktuellen Monoms
  }                                                   // (also einen Monom weiter in der
}                                                     // Liste) gesetzt...

Ich habe nun den head und das ende beim Einlesen der Daten vorgegeben. So wäre das dann an der Aufgabenstellung vorbei?
was müsste ich denn nun genau mit dem Laufzeiger abändern ?
Ist mir gerade nicht so klar...
 

Niki

Top Contributor
Schau dir das an, das ist ohne diesen ganzen Schnickschnack, nur die funktionalität der verketteten Liste. Das sollte dir weiter helfen das mit dem Laufzeiger zu verstehen:
Code:
public class Polygon {
	private Monom first = null;
	private Monom aktuell = null;

	public Polygon() {

	}

	public void add(Monom m) {
		if (first == null) {
			first = m;
			aktuell = m;
		} else {
			// Verrechnen
			Monom exists = exists(m);
			if (exists != null) {

			} else {
				aktuell.setNext(m);
				aktuell = m;
			}
		}
	}

	private Monom exists(Monom m) {
		Monom index = first;
		while (index != null) {
			if (m.getKoeffizient() == index.getKoeffizient())
				return index;
			index = index.getNext();
		}
		return null;
	}

	public void loeschen(Monom m) {
		if (m == first) {
			if (first == aktuell)
				aktuell = null;
			first = m.getNext();
		} else {
			Monom prev = getPrev(m);
			if (prev != null) {
				if (aktuell == m) {
					aktuell = prev;
				}
				prev.setNext(m.getNext());
			}
		}
	}

	private Monom getPrev(Monom m) {
		Monom index = first;
		while (index != null) {
			if (index.getNext() == m)
				return index;
			index = index.getNext();
		}

		return null;
	}

	public void print(Monom m) {
		if (m != null) {
			System.out.print(m.getExponent());
			Monom index = m.getNext();
			while (index != null) {
				System.out.print(" " + index.getExponent());
				index = index.getNext();
			}
			System.out.println();
		}
	}

	public void print() {
		Monom index = first;

		while (index != null) {
			System.out.print(index.getExponent());
			index = index.getNext();
			if (index != null)
				System.out.print(" ");
		}
		System.out.println();

	}

	public static void main(String[] args) {
		Monom m1 = new Monom(1, 1);
		Monom m2 = new Monom(2, 2);
		Monom m3 = new Monom(3, 3);
		Monom m4 = new Monom(4, 4);
		Monom m5 = new Monom(5, 5);
		Polygon p = new Polygon();
		p.add(m1);
		p.add(m2);
		p.add(m3);
		p.add(m4);
		p.add(m5);

		p.loeschen(m1);

		p.print();
	}
}

Code:
public class Monom {
	private int koeffizient = 0;
	private int exponent = 0;
	private Monom next = null;
	
	public Monom(){
		
	}
	
	public Monom(int k, int e){
		this.koeffizient = k;
		this.exponent = e;
	}

	public int getKoeffizient() {
		return koeffizient;
	}

	public void setKoeffizient(int koeffizient) {
		this.koeffizient = koeffizient;
	}

	public int getExponent() {
		return exponent;
	}

	public void setExponent(int exponent) {
		this.exponent = exponent;
	}

	public Monom getNext() {
		return next;
	}

	public void setNext(Monom next) {
		this.next = next;
	}

}
 

bladerama

Mitglied
Ist mein Lösung so denn nun an der Aufgabenstellung vorbei?!

ich mein ich kann das nun einfach so implementieren das der Laufzeiger immer auf das zuletzt eingefügte Monom zeigt, nur benutze ich ihn zur zeit ja gar nicht in meinem Code.
Wäre das problematisch?
 

Marco13

Top Contributor
Wohl nicht. Allerdings sollte man 'ende' und 'p' vmtl. nicht brauchen (und schon gar nicht public). Ich nehme an, dass an den stellen, wo du 'aktuellerMonom' geschrieben hast, einfach der 'laufzeiger' verwendet werden sollte.
 

bladerama

Mitglied
ok das mit dem ende verstehe ich. aber wieso nicht das p?
Man übergibt doch ein monom p, welches auf koeff und exp besteht...
 

bladerama

Mitglied
Code:
import java.io.*;
class Monom                                        //class Monom wird deklariert
{

  Monom naechster;                                 //-Der Zeiger auf den nächsten Knoten...
  int koeffizient;                                 //Variable koeffizient wird deklariert
  int exponent;                                    //Variable exponent wird deklariert

  Monom(int k, int e)                               //Der Konstruktor von Monom lässt koeffizient
  {                                                 // und exponent auf die Variablen zeigen, welche
    koeffizient = k;                                // dem Monom zugewiesen werden
    exponent = e;
  }

  // Hauptprozedur

  public static void main(String[] params)throws IOException{

         Polynom liste = new Polynom ();
         Polynom liste2 = new Polynom ();
         //liste2.Einlesen("Polynom.txt",1);
         liste.Einlesen("Polynom2.txt",5);
         //Monom p = new Monom(5,1);
         //liste.Einfuegen(p);
         //liste.Loeschen(p);
         liste.ausgeben();
         // System.out.println();
         //  liste2.ausgeben();
    }
  // Ende Ereignisprozeduren
  } /* Knotentyp */

class Polynom                                     //class Polynom welche die nötigen Prozeduren beinhaltet
{
Monom head;                                       //head wird instanziert
Monom ende;                                       //ende wird instanziert
Monom laufzeiger;                                 //laufzeiger wird instanziert
Monom p;                                          //p wird instanziert

  public void Einfuegen(Monom p)                  //Die Methode Einfuegen
  {
      int hdiff;                                  //Differenz zwischen Exponent Monom P und des bereits eingelesenen Polynoms
      hdiff = (p.exponent - head.koeffizient);

      if (p.exponent > head.koeffizient)          //Größenvergleich der beiden Exponenten, falls exp Monom P erzeuge 0-Monome...
        {
          head.koeffizient = p.exponent;
          for (int j = hdiff; j > 1;j--)
          {
              Monom neuKnoten = new Monom(0,p.exponent - j);
              neuKnoten.naechster  = head.naechster;
              head.naechster = neuKnoten;
          }
              Monom neuKnoten = new Monom(p.koeffizient,p.exponent);
              neuKnoten.naechster  = head.naechster;
              head.naechster = neuKnoten;
         }
      else
      {
          Monom laufzeiger = head.naechster;        //Der Kopf mit Inhalt "hoechster Expo" wird ausgelassen

       while (laufzeiger != null)                   //Durchlaufen der Knoten und abgleich mit deren Exponenten
          {                                         //Sind die Exponenten gleich wird verrechnet
            if ( laufzeiger.exponent == p.exponent )
            {
              laufzeiger.koeffizient += p.koeffizient;
              return;
            }
            
            laufzeiger = laufzeiger.naechster;      //Laufzeiger zeigt auf dem nächsten Knoten
          }
       }

   }

   public void Loeschen(Monom p)                    //Die Löschen-Methode
   {
    Monom laufzeiger = head.naechster;              //Auch hier wird der Kopf direkt ausgelassen.
    while (laufzeiger != null)                      //Knoten werden durchlaufen solange Laufzeiger nicht auf null zeigt
          {
            if ( laufzeiger.exponent == p.exponent )
            {
              laufzeiger.koeffizient = 0;           //Koeffizientzient wird auf 0 gesetzt. ( gelöscht )!
              return;
            }

            laufzeiger = laufzeiger.naechster;    //Laufzeiger zeigt auf dem nächsten Knoten
          }
   }
   

  public void Einlesen(String dateiname, int position) throws FileNotFoundException, IOException      // die Einlesen- Methode
    {
      BufferedReader in = new BufferedReader(new FileReader(dateiname));                              //Einlesen der Datei + übergabe Dateiname


     for (int k = 1;k < position;k++)                                  //Durchrücken der Zeilen der Datei damit bei der richtigen
     {                                                                //Zeile angefangen wird einzulesen
       in.readLine();
     }
       String zeile;                                                   // Hilfsvariable um den
       String hoechsterexponento = in.readLine();                      // Hoechsten exponentonenten einzulesen
       int h = Integer.parseInt(hoechsterexponento);                   // String in int umwandeln
       if (h < 0 )                                                     //Hilfsfunktion, falls ein Wert kleiner Null in der ersten Zeile steht
       System.out.println("Fehler hoechster exponentonent negativ");
       else
       {

       int[] a = new int[h + 2];                                    // Array instanzieren
       a[0] = h;                                                    // Der hoechste Exponent wird in ein Array übergeben

       for (int i = 1; i <= h + 1; i++)                             // Einlesen der Polynomglieder(koeff, exp) in Arrays
     {
        zeile = in.readLine();                                      //Einlesen der Zeile
        int zahl = Integer.parseInt(zeile);                         //String in int umwandeln
        a[i] = zahl;                                                //Int zahl in array speichern
     }


        this.head = new Monom(h,0);                                  //erzeuge Kopf der Kette und direktes einelsen der Daten für diesen Knoten
        this.ende = new Monom(a[h+1],0);                             //erzeuge Ende der Liste und direktes einlesen der Daten für diesen Knoten
        head.naechster= ende;                                        //setze head auf ende
        ende.naechster= null;                                        //setze ende auf null

        for (int j = h; j >= 1;j--)                                  //Einfuegen der restlichen Listenglieder
         {
            Monom neuKnoten = new Monom(a[j],h - j + 1);             //Neue Knoten werden eingelesen und zugewiesen
            neuKnoten.naechster  = head.naechster;                   //alles wird hinter head eingefügt
            head.naechster = neuKnoten;                              //und richtig verwiesen
        }
        
    }
   }                                                                 //Ausgeben Methode
public void ausgeben()
  {
    Monom laufzeiger = head;                                         //Die Variable laufzeiger wird auf head gesetzt

    while (laufzeiger != null)                                       //Die Liste ab head durchlaufen bis ende auf "null" zeigt

    {
      System.out.print(laufzeiger.koeffizient + " ");                //Ausgabe des Koeffizienten des aktuell durchlaufenen Monoms
                                                                     // ( nach Aufgabenvorgabe)

      laufzeiger = laufzeiger.naechster;                             //laufzeiger wird durchgerückt
    }                                                                //
  }
}

Hi Leute, danke erst mal für die ganze Hilfe!
Das ist vorläufig mein Code.
Kann vllt noch mal jemand drüberschauen. Auch wegen Kommentierung.
Hab das leider nicht hinbekommen, es ohne "ende" zu programmieren.

Was gibt es zu bemängeln?
 

bladerama

Mitglied
hi noch eine neue Frage...

ich habe nun noch eine Methode zu schreiben, die zwei Polynome addiert.

diese Addition soll ich ja über meine Methode Einfuegen realisieren

Code:
 public void Einfuegen(Monom p)                  //Die Methode Einfuegen
  {
      int hdiff;                                  //Differenz zwischen Exponent Monom P und des bereits eingelesenen Polynoms
      hdiff = (p.exponent - head.koeffizient);

      if (p.exponent > head.koeffizient)          //Größenvergleich der beiden Exponenten, falls exp Monom P erzeuge 0-Monome...
        {
          head.koeffizient = p.exponent;
          for (int j = hdiff; j > 1;j--)
          {
              Monom neuKnoten = new Monom(0,p.exponent - j);
              neuKnoten.naechster  = head.naechster;
              head.naechster = neuKnoten;
          }
              Monom neuKnoten = new Monom(p.koeffizient,p.exponent);
              neuKnoten.naechster  = head.naechster;
              head.naechster = neuKnoten;
         }
      else
      {
          Monom laufzeiger = head.naechster;        //Der Kopf mit Inhalt "hoechster Expo" wird ausgelassen

       while (laufzeiger != null)                   //Durchlaufen der Knoten und abgleich mit deren Exponenten
          {                                         //Sind die Exponenten gleich wird verrechnet
            if ( laufzeiger.exponent == p.exponent )
            {
              laufzeiger.koeffizient += p.koeffizient;
              return;
            }
            
            laufzeiger = laufzeiger.naechster;      //Laufzeiger zeigt auf dem nächsten Knoten
          }
       }

   }


Nun habe ich aber leider folgendes Problem:

Code:
 public void Addition()

{
  Monom laufzeiger = head.naechster;        //Der Kopf mit Inhalt "hoechster Expo" wird ausgelassen

while (laufzeiger != null)
{
Einfuegen(laufzeiger);
laufzeiger = laufzeiger.naechster;
}


}

Dann verrechnet er mir mein Polynom1 mit Polynom1. Wie bekomme ich das hin, dass er Polynom1 mit Polynom2 verrechnet?!
 

Marco13

Top Contributor
Monom head; //head wird instanziert
"Instanziieren" ist das mit "new...". Dort wird nur etwas deklariert.

Die Zeile
Monom p;
hab' ich gerade mal auskommentiert - das macht keinen Unterschied, und IST demnach schon überflüssig.

Das 'ende' sollte auch überflüssig sein. Es gibt ja keinen Grund, warum das hier
this.ende = new Monom(a[h + 1], 0); //erzeuge Ende der Liste und direktes einlesen der Daten für diesen Knoten
schon erzeugt werden soll. Eigentlich muss auch nicht erst alles in einen Array eingelesen werden. Im Pseudocode könnte das einlesen so aussehen
Code:
void lese()
{
    head = null;
    laufzeiger = null;

    int maxExponent = lese();
    float koeffizient = lese();
    head = erstelle(koeffizient);
    laufzeiger = head;
    for (int i=1; i<maxExponent; i++)
    {
         koeffizient = lese();
         laufzeiger.next = erstelle(koeffizient);
         laufzeiger = laufzeiger.next;
    }
}
 
Status
Nicht offen für weitere Antworten.
Ähnliche Java Themen
  Titel Forum Antworten Datum
Zrebna Frage zu Test-Driven Development (TDD) Java Basics - Anfänger-Themen 3
I Frage Thymeleaf -> Fehler ignorieren und mit "" ersetzen? Java Basics - Anfänger-Themen 15
I Frage Thymeleaf -> Prefix / Suffix ändern? Java Basics - Anfänger-Themen 11
D Rekursions Probleme / frage Java Basics - Anfänger-Themen 4
T Frage zu Parse Java Basics - Anfänger-Themen 2
H Frage an die Profis Java Basics - Anfänger-Themen 4
J Eine konzeptionelle Frage zu OOP Java Basics - Anfänger-Themen 3
P Frage zu Rekursion und Backtracking Java Basics - Anfänger-Themen 2
H Frage zur Ausgabe Java Basics - Anfänger-Themen 4
H Frage zu arithmetischen Operationen Java Basics - Anfänger-Themen 20
F Kurze Frage zu replace() Java Basics - Anfänger-Themen 19
JavaSchmecktLecker Polymorphie Frage zur Methodenüberschreibung Java Basics - Anfänger-Themen 21
J Frage zu einem "Taschenrechner" code Java Basics - Anfänger-Themen 9
B Erste Schritte Frage zu Instanzierung und Referenzen Java Basics - Anfänger-Themen 8
DoubleM Runtime.getRuntime().exec Frage Java Basics - Anfänger-Themen 2
J Eine theoretische Frage zur Praxis - JPanel oder Canvas Java Basics - Anfänger-Themen 5
O Frage: Formaler Typbezeichner? Java Basics - Anfänger-Themen 3
I BlueJ Queue Frage für Klausur Java Basics - Anfänger-Themen 2
N Verständnis Frage zu Variablen Java Basics - Anfänger-Themen 3
N Spezielle frage zum Comparator Java Basics - Anfänger-Themen 6
L Frage zum Array Java Basics - Anfänger-Themen 1
A Frage zum UML Design Java Basics - Anfänger-Themen 1
I Hilfe bei Klausur Frage Java Basics - Anfänger-Themen 8
izoards Drucken Frage zu FAQ Beitrag Java Basics - Anfänger-Themen 2
J Frage zu meinem Code (OOP) Java Basics - Anfänger-Themen 4
sserio Split() -> Regex Frage. Java Basics - Anfänger-Themen 7
A OCA Study Guide: 2. Frage aus Kapitel 3 Java Basics - Anfänger-Themen 9
sserio Date Library Frage Java Basics - Anfänger-Themen 9
Max246Sch Frage zu Währungsrechner Code Java Basics - Anfänger-Themen 2
sserio Frage zu HashMaps Java Basics - Anfänger-Themen 20
sserio Frage zu Threading - Multithreading Java Basics - Anfänger-Themen 2
sserio Frage zu Lambda Ausdrücken Java Basics - Anfänger-Themen 7
sserio Frage zu BigInteger Java Basics - Anfänger-Themen 1
D Frage bzgl. Enum-Handhabung Java Basics - Anfänger-Themen 16
xxx12 Frage Java Basics - Anfänger-Themen 2
I Generelle Frage zu Mikroservices (Spring Boot?), Docker... Java Basics - Anfänger-Themen 7
R Frage zu Methoden (Rückgabewert u. ohne.) Java Basics - Anfänger-Themen 2
A Frage zur programmierung Java Basics - Anfänger-Themen 12
M Frage zur Methode split der Klasse String Java Basics - Anfänger-Themen 32
R Input/Output Frage zu Java IO Java Basics - Anfänger-Themen 6
M Frage zu printWriter Java Basics - Anfänger-Themen 5
C Frage zu OLSMultipleLinearRegression Java Basics - Anfänger-Themen 31
KogoroMori21 Frage zum Euklidischen Algorithmus Java Basics - Anfänger-Themen 11
S Verständnis-Frage zu einer HÜ? Java Basics - Anfänger-Themen 1
F Frage betreff Programm mit dem man C++-Code in JAVA-Code übersetzen lassen kann Java Basics - Anfänger-Themen 2
L Frage zur Ticket Maschine Java Basics - Anfänger-Themen 1
J Frage zu OOP-Klassendiagramm Java Basics - Anfänger-Themen 8
OSchriever Frage zu Compiler Java Basics - Anfänger-Themen 8
H Frage zu Throw Exception Java Basics - Anfänger-Themen 2
TimoN11 Frage zu Java-Vererbung (Cast) Java Basics - Anfänger-Themen 5
Bademeister007 Hallo Leute ich hab eine Frage zur ArrayList Java Basics - Anfänger-Themen 8
F Frage betreff Programmierbücher zu Lagerverwaltung als Konsolenprogramm Java Basics - Anfänger-Themen 3
dieter000 Kurze Frage kann mir ejmand kurz diesen Code erklären, bzw wie man die zeilen erklärt und so Java Basics - Anfänger-Themen 1
I String.split regex Frage Java Basics - Anfänger-Themen 2
N Best Practice Frage zum MVC-Pattern Java Basics - Anfänger-Themen 2
dieter000 Frage zu einem Beispiel... Java Basics - Anfänger-Themen 5
J Frage zum Loggen Java Basics - Anfänger-Themen 18
J Methoden Frage: Array-Werte in anderer Methode ändern Java Basics - Anfänger-Themen 4
Zrebna Frage zum "Referenzen-konzept" in Java Java Basics - Anfänger-Themen 8
JD_1998 Array-Position aus einer Methode in einer anderen ausgeben (Kurze Frage) Java Basics - Anfänger-Themen 2
marcooooo Frage zu bestimmten Beispiel Java Basics - Anfänger-Themen 31
NeoLexx equals()-Methode Verständnis Frage anhand Code Beispiel Java Basics - Anfänger-Themen 22
N Input/Output Eine Frage über system.out.println. Java Basics - Anfänger-Themen 10
B Erste Schritte Learning Coding (!) Frage an erfahrene Programmierer. Java Basics - Anfänger-Themen 23
M konzeptuelle Frage: In welcher Klasse definiert man am Besten Methoden, die die Kommunikation mit dem User regeln? Java Basics - Anfänger-Themen 8
B Frage zum Code verständnis im Resultat Java Basics - Anfänger-Themen 10
C Exception-Frage Java Basics - Anfänger-Themen 3
J Eine Frage zur Schreibweise == ? : Java Basics - Anfänger-Themen 3
S Frage des Designs Java Basics - Anfänger-Themen 1
JavaTalksToMe Extends/Implements Frage Java Basics - Anfänger-Themen 3
pkm Frage zu Servletfunktion Java Basics - Anfänger-Themen 0
B Frage zur Währungsumrechnung Java Basics - Anfänger-Themen 3
S Allgemeine Frage über Generics und Vererbungen Java Basics - Anfänger-Themen 5
Kirby.exe Frage zur Verwendung von Interfaces Java Basics - Anfänger-Themen 6
D Frage zu Strings einer Exception Java Basics - Anfänger-Themen 4
L Wie frage ich ab, ob in einem Array, Werte doppelt vorkommen? Java Basics - Anfänger-Themen 4
D Frage zur IDE IntelliJ IDEA Java Basics - Anfänger-Themen 6
H Frage zum 2d Array Java Basics - Anfänger-Themen 1
N Frage zum Newton-Fraktal Java Basics - Anfänger-Themen 1
H Frage zu interfaces Java Basics - Anfänger-Themen 1
J Frage dazu Variablen klassenübergreifend zu verändern Java Basics - Anfänger-Themen 22
I Frage zu SkipList Java Basics - Anfänger-Themen 4
G Frage zu JScrollPane Java Basics - Anfänger-Themen 12
Kirby.exe Allgemeine Frage Java Basics - Anfänger-Themen 3
W Frage zu anonymen Klassen Java Basics - Anfänger-Themen 4
J Kleine Frage zu OOP Java Basics - Anfänger-Themen 371
S Frage Klasse und Objekte Java Basics - Anfänger-Themen 2
F Frage zu Iteratoren Java Basics - Anfänger-Themen 2
C Erste Schritte Frage zur ArrayList Java Basics - Anfänger-Themen 15
J Frage zur Vererbung Java Basics - Anfänger-Themen 1
H Frage zur ermittlung eines doppelte Paars aus Sotieralgorithmus Java Basics - Anfänger-Themen 4
H Frage zum Array Java Basics - Anfänger-Themen 17
G Schach -Frage 2- Maussteuerung Java Basics - Anfänger-Themen 7
G Schach in Java - Allgemeine Frage zur Architektur Java Basics - Anfänger-Themen 7
B Fachliche Frage bei Rechnungen Java Basics - Anfänger-Themen 16
B Frage zu: String... strings -> Ungleiche Anzahl an Parameter? Java Basics - Anfänger-Themen 4
B Frage zu Datenbank Design - Rechnungen, Angebote... und deren Positionen Java Basics - Anfänger-Themen 4
H Frage zu Parameter einer Methode Java Basics - Anfänger-Themen 2
H Einfache Frage zur Punktnotation objektname.methode(wert) Java Basics - Anfänger-Themen 2
H Frage zu Parameter einer Methode Java Basics - Anfänger-Themen 3

Ähnliche Java Themen

Neue Themen


Oben