Rekursion

[TNT]

Ich sitze gerade an folg. Aufgabe:

Schreiben Sie eine rekursive Methode

public static void reverseNumber(int zahl)

zur Ausgabe aller Ziffern der positiven ganzen Zahl zahl.

Hinweise:

* Die letzte Ziffer kann mit zahl%10 abgespalten werden.
* Der vordere Teil der Zahl entspricht zahl/10.
* Die Methode soll außer zahl keine zusätzlichen Variablen verwenden.
* printNumber(123) soll nacheinander die Ziffern 3, 2 und 1 ausgeben.


Hört sich ja ansich nicht schwierig an, nur schein ich was gegen die Rekursion zu haben, ich würde das am liebsten mit nem Vertauschen machen.
Kann mir wer helfen?

 

[messi]

public static void reverseNumber(int zahl) {
    System.out.println((char) ((zahl % 10) + '0'));
    if (zahl >= 10)
        reverseNumber(zahl / 10);
}

 

[Bleiglanz]

gibts irgendeinen grund für diese Konstruktion?

System.out.println((char) ((zahl % 10) + '0')); // warum ?

eher so

    private static void reverseNumber(int zahl){
        System.out.print(zahl % 10);
        if (zahl>9) {
            reverseNumber(zahl / 10);
        } else {
            System.out.println();
        }
    }

 

[Gast]

(Past gerade zu diesem trade...)

moinmoin

Ein Problem mit der Rekursion und untertabellen usw...

Ziel:

Ausgabe in soeiner Form:

Ordner1 { Inhalt2 wert
               Inhalt3 wert
               Ordner2 { inhalt4 wert
                            }
               Ordner14 { inhalt34 wert
                                Ordner26 { inhalt52 wert
                                               }
                                inhalt23 wert
                              }
               inhalt52 wert
               inhalt 12 wert
               inhalt 52 wert

uswuswusw....

(* wert kann irgend was sein, einfach der wert des inhaltes. )

pseudocode für die realisierung:

public static testClass(int abstand){

//schreibe Name, von Ordner oder inhalt
abstand = abstand + laengeName

if (Ordner){
    System.out.print(" { ");
    //Rekursion:
    testClass();
    //abstand für die darstellung:
    for(int a = 0; a<abstand; a++){
      System.out.print(" ");
    }
     System.out.print(" } ");
else{
//else if inhalt
    //schreibe Inhalt und Wert
    //newline:
      System.out.println("");
  }

}

Nunja, irgend wo muss ein problem mit der rekursion sein, ich seh nur nicht wo, habt ihr einen Vorschlag?
ich hoff ihr erkennt ein bisl was vom Pseudocode ... Macht euch aber nicht irgend wie zu viele gedanken darüber,
von wo ihr nun den namen vom inhalt oder den wert herhabt, das ist nicht das Problem das ich hab, es geht um
die Darstellung.

thx und grüsse

 

[Guest]

hmm, braucht ihr sonst was um mir vielleicht zu helfen? Hab ich zu wenig infos gegeben? zu unverständlich?

MfG

 

[norman]

Ich steig da jedenfalls nicht durch was dein Ziel ist..was soll denn "Ordner" und "Wert" usw. darstellen? bzw wass soll der methode übergeben werden, und was soll sie zurückliefern/ leisten?

 

[Guest]

Was zurück gegeben wird, oder was übergeben wird, ist nicht wichtig.
diese Funktion ist lediglich für die darstellung wichtig.
Man kann sich das vorstellen wie mit normalen ordnern und dateien und ihrer HIRARCHIE...
Ich weis nur nicht wie ich das mit der HIRARCHIE hinbekomme, das unterordner und Dateien dann auch wirklich richtig strukturiert werden (mit einrückung und {} unso). Dass müste ja mit einer Rekursion möglich sein. Ich seh nur nicht wie ich das realisieren kann, ich bräuchte ja net irgend wie den vollen code, wo ihr dann auch alle methoden mit ihren rückgabewerten usw gebt.

hmm, oder anderst gefragt, wie kann ich mit Rekursion einen Solche Struktur wie hier:

-----------------------------------------

Ordner1 { Inhalt2 wert
Inhalt3 wert
Ordner2 { inhalt4 wert
}
Ordner14 { inhalt34 wert
Ordner26 { inhalt52 wert
}
inhalt23 wert
}
inhalt52 wert
inhalt 12 wert
inhalt 52 wert

uswuswusw....

(* wert kann irgend was sein, einfach der wert des inhaltes. )

------------------------------------------

realisieren.
(Der Pseudocode ist eben meine Variante die aber nicht funktioniert =) )

MfG

 

[Guest]

Struktur ist gerade scheisse rausgekommen, nomals :

Ordner1 { Inhalt2 wert
               Inhalt3 wert
               Ordner2 { inhalt4 wert
                            }
               Ordner14 { inhalt34 wert
                                Ordner26 { inhalt52 wert
                                               }
                                inhalt23 wert
                              }
               inhalt52 wert
               inhalt 12 wert
               inhalt 52 wert

uswuswusw....

(* wert kann irgend was sein, einfach der wert des inhaltes. )

 

[norman]

ich denke es ist schon wichtig, ob die methode einen String übergeben bekommt, oder ein File-Objekt oder sonstiges :bahnhof:
ansonsten verstehe ich die frage wohl immernoch nicht ganz ???:L

 

[Guest]

ok,
Die methode lautet:
public static boolean testMethode(DataInputStream inputStream, PrintStream outputPrintStream, int abstand)

es wird von einer .txt Datei herausgelesen.
Die txt datei wird decodiert, und besitzt eben eine Hierarchie. Diese Hierarchie muss ich irgend wie lesbar darstellen.
Alles ist bereits richtig Programmiert, alles das decodier zeugs halt, nuuur die Darstellung für die Ausgabe, um es auch leserlich zu machen, das funktioniert net wirklich.

Einen Weiteren Pseudocode:

public static boolean testMethode(DataInputStream inputStream, PrintStream outputPrintStream, int abstand)

    try {
          
          //Check if Ordner oder Datei
          //Decode Name von Ordner oder Datei

          //"abstand" braucht man für die Darstellung der hirarchie, wenn halt unter ordner oder unter dateien 
          // dargestellt werden müssen, müssen die mehr rechts sein. 
          //namensgrösse ist, wieviele zeichen der name hat, also z.B. Ordner12 hat 8 Zeichen
          abstand = abstand + namensGroesse;
          //Da sie statisch ist, wieder auf NULL setzen
          namensGroesse=0;
          if (Ordner) {
              outputPrintStream.print(" { ");
            }
 
           //abstand + 2, weil es noch 2 abstände hat
            testMethode(inputStream, outputPrintStream, abstand=abstand+2);
            //indent Blanks, Abstände hinzufügen
            //dadurch dass wir die abstände des Namens gespeichert haben, können wir die für die darstellung 
            //gebrauchen:
            for (int abstandCounter=0; abstandCounter<abstand; abstandCounter++){
              //Ein Leerzeichen
              outputPrintStream.print(" ");
             }
              //am schluss wird dann ein Semikolon gesetzt, um die Struktur abzuschliessen
              outputPrintStream.print(" } ");  
            
          }else{
            //Unwichtig was in diesem Funktionsaufruf steht und ist. 
            schreibeWertVonDatei(outputPrintStream, inputStream, pos, laenge);
            //new line für Darstellung (printLN)
            outputPrintStream.println("");
          }
    }
    catch (IOException e) {
      return false;
    }
    return true;
  }

Besser?
Aber könnt ihr mein Problem erkennen? Ich will nur die Darstellung korrekt haben, dies funzd aber noch net.

 

[one44]

Immer noch nicht? =(

 

[norman]

fürchte mir ist es zu abstrakt. sry

bleiglanz? roar? stevg? ihr wisst doch immer alles *g*

 

[one44]

"Ringsherum ein riisen rumor, nur hier, an diesem bescheidenen ort, wo sich die Nacht vom Tage trennt, STILLE!"

;D

 

[Bleiglanz]

          abstand = abstand + namensGroesse;
          namensGroesse=0;
          if (Ordner) {

du postest eine Methode, wo in den ersten drei Zeilen zwei Membervariablen der Klasse vorkommen??

sollen wir hellsehen?

testMethode(inputStream, outputPrintStream, abstand=abstand+2);

watn das? Rekursion? Warum?

 

[one44]

          abstand = abstand + namensGroesse;
          namensGroesse=0;
          if (Ordner) {

du postest eine Methode, wo in den ersten drei Zeilen zwei Membervariablen der Klasse vorkommen??

sollen wir hellsehen?

Na, das schon net, aber ich weiss net was du über die sonst noch wissen willst

testMethode(inputStream, outputPrintStream, abstand=abstand+2);

watn das? Rekursion? Warum?

Naja, darum hab ich das Thema auch unter Rekursion genommen. Ich habe oben beschrieben, was die ausgabe sein soll, und irgend wie klabt halt das mit der rekursion net...

hmm, wenn sonst niemand vielleicht gerade weiter weis, dan werde ich anderswo weitersuchen nach der lösung.

greezn

 

[Bleiglanz]

Ordner1 { Inhalt2 wert
               Inhalt3 wert
               Ordner2 { inhalt4 wert
                            }
               Ordner14 { inhalt34 wert
                                Ordner26 { inhalt52 wert
                                               }
                                inhalt23 wert
                              }
               inhalt52 wert
               inhalt 12 wert
               inhalt 52 wert

du willst so eine Ausgabe produzieren, d.h. Einrückungen gemäss der Hierarchie audrucken

aber was ist der Input???

 

[one44]

(ja, so eine ausgabe)
Meinst du DataInputStream inputStream?

Wird gebraucht um aus der Datei zu lesen. (Die Datei die encodiert wird, und dann eben schön dargestellt werden muss. )

 

[norman]

die frage war glaube ich, was in der Datei drin steht bzw wie die aufgebaut ist ???:L

 

[one44]

, ok
Die Datei:
es ist ein Byte code, diesen encodiere ich mit basicEncodingRools.

 

[one44]

Sorry, war bisl länger weg.

Also das da oben hilft in diesem Falle keinem, also in einfachen worten:

ich will: rekursiv eine Ordnerstruktur auslese.

Wie würde der Code, Ablauf aussehen? (könnt ihn sonst auch mit pseudocode darstellen. )

thx

 

[norman]

ich würde sagen dann in etwa so:

File ordner = new File("dein_Ordner");
blabla(ordner);

[...]

public void blabla(File ordner) {
   File[] ordnerInhalt = ordner.listFiles();
   for (int i=0; i<ordnerInhalt.length(); i++) {
      if (ordnerInhalt[i].isDirectory())
         blabla(ordnerInhalt[i]);
      else if (ordnerInahlt[i].isFile()) {
         System.out.println(/*was auch immer du willst*/);
         // und was du halt sonst noch mit den Dateien anstellen willst..
      }
   }
}

 

[one44]

Gilt das auch für verschachtelte Ordner?
rekursiv eine Ordnerstruktur auslese:

Ordner1
           File1
           Ordner2
                      Ordner3
                      File2
                      File3

Hab dein Beispiel auch bei meinem verwendet, aber ich vermassle da glaube ich irgend etwas mit den Abständen (für die Darstellung halt. ).
Wo müsten die reinkommen im Code?

 

[norman]

Gilt das auch für verschachtelte Ordner?

ja, wenn ein ordner gefunden wurde, rufst du die methode ja erneut auf und nimmst den gefunden ordner als wurzel..
für die einrückungen fällt mir spontan nur ein counter ein, der die ebenen mitzählt (also anzahl der aufrufe der methode). dann kannst du z.B.

final int EINR_JE_EBENE = 3;
int anz = EINR_JE_EBENE * counter;
String einr="";
for (int i=0; i < anz; i++) {
   einr = einr.concat(" ");
}

an entsprechender stelle (also wohl vor der ausgabe des dateinamens) einfügen.
allerdings scheint mir die konstruktion des x leerzeichen langen strings ziemlich umständlich..gibt sicherlich besseres :###

[edit] bisschen einfacher wäre es wohl schon, die konstante zu verwerfen und gleich immer zB 3 leerzeichen anhängen (also einr.concat("___"); .. oder ein final String EINZUG = "___"; und einr.concat(EINZUG)
also:

final int EINZUG = "___";
int counter;
String einr;
[...]
einr="";
for (int i=0; i<counter; i++)
   einr=einr.concat(EINZUG);

 

[one44]

File ordner = new File("dein_Ordner");
blabla(ordner);

[...]

public void blabla(File ordner) {
   File[] ordnerInhalt = ordner.listFiles();
   for (int i=0; i<ordnerInhalt.length(); i++) {
      if (ordnerInhalt[i].isDirectory())
         blabla(ordnerInhalt[i]);
      else if (ordnerInahlt[i].isFile()) {
         System.out.println(/*was auch immer du willst*/);
         // und was du halt sonst noch mit den Dateien anstellen willst..
      }
   }
}

Das klapt jetzt mal...

Nun ist noch das prob wenn ich für die Darstellung z.B. zusätzlich noch:

Ordner1{
             File1
             Ordner2{
                         Ordner3{File5
                                     }
                         File2
                         File3
                    }
         }     
Ordner12{
               File6
               File13
               Ordner13{File65
                              File66
                        }
          }

Damit man auch sieht was zu was hingehört...

Mit dem Einzug, setzt es den auch irgend wann wieder auf null? Für in diesem Falle halt Ordner12...

thx

EDIT:
Sorry, irgend wie mit den Abständen komt net schön raus und mit dem abschluss von }.. Aber ich hoff ihr seht was ich meine...

 

[Leroy42]

Drehen wir das ganze mal um damit wir hier weiterkommen

Hier mal ein fertiges Programm daß eine rekursive Datenstruktur so
ausgibt wie du es dir vorstellst:

class RekData {}

class Ordner extends RekData {
	RekData[] kinder;
	public Ordner(RekData[] kinder) {
		this.kinder = kinder;
	}
}

class Inhalt extends RekData {
	String name;
	Object wert;
	public Inhalt(String name, Object wert) {
		this.name = name;
		this.wert = wert;
	}
}

public class Ausgabe {
	public static void main(String[] args) {
		RekData data =
			new Ordner(
				new RekData[] {
					new Inhalt("inhalt1", "wert1"),
					new Ordner(
						new RekData[] {
							new Inhalt("inhalt21", "wert21"),
							new Inhalt("inhalt22", "wert22"),
							new Inhalt("inhalt23", "wert23")
						}),
					new Inhalt("inhalt3", "wert3")
				});
		ausgabe(data);
	}

	static void ausgabe(RekData data) {ausgabe(data, 0);}
	static void ausgabe(RekData data, int deep) {
		deep(deep);
		if (data instanceof Ordner) {
			Ordner x = (Ordner) data;
			System.out.println("Ordner {");
			for (int j=0; j < x.kinder.length; ++j)
				ausgabe(x.kinder[j], deep+1);
			deep(deep);
			System.out.println("}");
		} else {
			Inhalt x = (Inhalt) data;
			System.out.println(x.name + " = " + x.wert);
		}
	}

	static void deep(int deep) {
		for (int i=0; i < deep; ++i)
			System.out.print("   ");
	}
}

Ein RekDate ist hier entweder ein Inhalt (Name-Wert-Paar)
oder ein Ordner (Array von RekDates). Die Ausgabe erfolgt hier in
den zwei Methoden ausgabe und erledigt das Gewünschte.

Ich hab' auf die Schnelle einige Programmierrichtlinien außer acht gelassen
um die prinzipielle Vorgehensweise deutlicher herauszustellen. Z.B.:

- Die Ausgabemethoden sollten nicht static sein
- Es sollten Methoden der Klassen selbst sein, dann entfällt auch das Herumhantieren mit instanceof
- Es sollten nur getter/setter-Methoden benutzt werden.

Du mußt jetzt vor allem erst mal deine rekursive Datenstruktur festlegen
und anhand des Beispiels eine entsprechende Ausgabemethode implementieren.

Beispielweise sollte System.out.print nicht fest verdrahtet werden, sondern
lieber ein String/StringBuffer Object geliefert werden oder die Ausgaben in einen,
mit zu übergebenden, Writer geschrieben werden, damit du die Ausgabe leicht umlenken
kannst (Konsole, Datei, GUI-Komponente, JTree, ...)

 

[one44]

ok, Danke, ich werde mir diese Programm genauer anschauen, danke für eure mühe.

 

[Leroy42]

Ach du meine Güte :shock:

Ich sehe gerade daß dieser Thread ja schon 2 Seiten hat und ich habe
auf den letzten Beitrag der ersten Seite geantwortet. Peinlich, peinlich

Also falls ihr das alles schon geklärt habt, entfernt einfach meinen Beitran

 

[Guest]

			for (int j=0; j < x.kinder.length; ++j)
				ausgabe(x.kinder[j], deep+1);

nene, nix entfernen ;D. Danke für das Beispiel.

Ich hab nur noch ein tilg in dieser FOR schleiffe.
Verstehe nicht was das "kinder[j]" soll.?

 

[The_S]

Du gibst in den eckigen Klammern hinter einem Array an auf welches Element des Arrays du zugreifen möchtest. Entweder mit einer festen Zahl oder eben mit einer Variablen.

 

[Guest]

aber ist: x.kinder.length, die länge des Ordners? Länge des inhaltes?

 

[Leroy42]

Meine Klassenstruktur war nur als Beispiel gedacht.
Du hast ja Ordner die aus beliebig vielen, von dir so genannten, Inhalten
oder wiederum (Unter)Ordnern bestehen. Ich habe das ganze einfach
mal so modelliert.

class RekData {}

Diese Klasse soll ein Unterelement deiner Ordner darstellen.
Also entweder ein Inhalt oder wiederum ein Ordner

class Ordner extends RekData { 
   RekData[] kinder; 
   public Ordner(RekData[] kinder) { 
      this.kinder = kinder; 
   } 
}

Diese Klasse stellt einen Ordner dar und ist eine Art Rekdata.
Sie besitzt eine beliebige Anzahl von Unterelementen die ich einfach
mal kinder genannt habe.

class Inhalt extends RekData { 
   String name; 
   Object wert; 
   public Inhalt(String name, Object wert) { 
      this.name = name; 
      this.wert = wert; 
   } 
}

Diese Klasse repräsentiert einen Inhalt der eben kein Ordner ist und
so auch keine Unterelemente besitzt.

Falls du z.B. ein Dateisystem darstellen willst, entspricht die Klasse
Inhalt einer Datei. In diesem Fall brauchen Instanzen
der Klasse Ordner natürlich auch einen Namen. Da also beide
Arten von RekData einen Namen haben, kannst du diese
Instanzvariable aus den beiden Klassen herausziehen und
direkt in RekData eintragen. Dann wäre RekData auch nicht so leer

 

[one444]

ook, mach ichs wie ihr es da an Beispielen sagt:
(Teil des CODES, für die Darstellung

  static void deep(int indent) {
    for (int i=0; i < indent; ++i)
       System.out.print("   ");
 } 



  public static boolean decodeSequence(DataInputStream inputStream, PrintStream outputPrintStream, int indent) {
    try {
          checkBlock=false;
          //Take byte of file
          int tagByte = nextByte(inputStream);
          //check if structuriertFlag (If Ordner)
          boolean structuriertFlag = isStructured(tagByte);

          deep(indent);

          //Decode and write TagName
          tagByte = writeTagName(inputStream, outputPrintStream, tagByte, structuriertFlag);
          //Decode Length, Länge Wert
          int laenge = decodeLaenge(inputStream, outputPrintStream, tagByte);
          
//IF STRUCTURIERT(Ordner)          
          if (structuriertFlag) {
            
            if(checkBlock==false){
              //schreibe "{"
              outputPrintStream.print(" { ");
            }
            
            for (int j=0; j<laenge; j++)
              //REKURSION
              decodeSequence(inputStream, outputPrintStream, indent+1);
              //indent Blanks, Abstände hinzufügen
              deep(indent);
              //schreibe "}"
              outputPrintStream.print(" } ");  


//IF VALUE (File)
          }else{
            //schreibe Wert in Hexadezimaler Darstellung
            writeTagValueHex(outputPrintStream, inputStream, tagByte, laenge);
            if(checkBlock==false){
              //schreibe new line
              outputPrintStream.println("");
            }
            //outputPrintStream.println("");
          }
    }
    catch (IOException e) {
      return false;
    }
    return true;
  }
}

So dinge wie: checkBlock oder all die Funktionen wie:writeTagValueHex, oder nextByte(); usw... müst ihr nicht beachten...
Ich bekomm jetzt dan ne kriise :shock: , bin die ganze zeit am ausprobieren, aber klapt einfach net!! joa, das ist noch mein letzter "hoffendlichsiehtjemandDenFehleroderkannIrgendwowashinzufügen". Nachher werde ich wohl einen Freund frage, den inmoment aber net da is...
greez