witch doctor

package baum; import java.io.*; class TreeTest { public static void main(String[] args) { MyTreeMap dictionary = new MyTreeMap(); dictionary.put("node", "Knoten"); dictionary.put("tree", "Baum"); dictionary.put("root", "Wurzel"); dictionary.put("left", "links"); dictionary.put("right", "rechts"); System.out.println(dictionary.size()); System.out.println("Engl.: "+"root"+" Dt.: "+dictionary.get("root")); System.out.println("Engl.: "+"node"+" Dt.: "+dictionary.get("node")); System.out.println("Engl.: "+"bla"+" Dt.: "+dictionary.get("bla")); dictionary.print(); if(dictionary.containsValue("Wurzel")) { System.out.print("Der Baum enthält diesen Wert \n"); } else { System.out.print("\n Wert nicht vorhanden \n"); } dictionary.remove("tree"); System.out.println(dictionary.size()); dictionary.print(); } } Das Wort "Wurzel" findet er. Sobald ich aber zB das Wort links angebe, findet er es nicht, obwohl es vorhanden. Wo ist der Fehler? Ich habe noch eine andere Lösung. Doch ich denke,dass diese noch falscher ist: boolean containsValue(Object o) { boolean result = false; Node tree=this.root; if(tree.value.equals(o)) { result=true; } if(tree.left.value.equals(o)) { result=true; } if(tree.right.value.equals(o)) { result=true; } return result; // Hier Lösung einfügen } Ich wäre für Hilfe sehr dankbar, da ich den Fehler nciht sehe. Wie durchlaufe ich denn am Besten einen Baum? Mit einer for Schleife? Nur mit welchen Werten? Ich danke euch bereits für eure Hilfe!

Wir haben mal folgende Aufgabe in Informatik erhalten: Hierzu das zu bearbeitende Programme /** * Implementierung eines binären Suchbaums * * Beachte: * Der Suchbaum ist kein ausgeglichener Baum. * Er kann durch Einfüge- und Löschoperationen zu einer * linearen Liste entarten. * * Die gespeicherten Objektreferenzen für Werte dürfen * nicht gleich null sein. * */ package TreePackage; public class MyTreeMap { /** * Innere Klasse für die Knoten des binären Sucbaumes */ class Node { // Attribute Comparable key; // Verweis auf Schlüssel-Objekt Object value; // Verweis auf Wert-Objekt Node left; // Verweis auf linken Kindknoten Node right; // Verweis auf rechten Kindknoten // Konstruktor Node(Comparable key, Object value) { this.key = key; this.value = value; this.left = null; this.right = null; } } // Attribute (Klasse MyTreeMap) private Node root; // Verweis auf Wurzelknoten des Binärbaumes private int size; // Anzahl der Knoten des Binärbaumes // Konstruktor (Klasse MyTreeMap) /** * Erzeugung eines leeren Binärbaums */ public MyTreeMap() { this.root = null; this.size = 0; } // Operationen (Klasse MyTreeMap) /** * Bestimmung der Anzahl der Knoten im Binärbaum */ public int size() { return this.size; } /* * Bestimmung eines Knotens, der einen vorgegebenen Schlüssel enthält * mit Hilfe eines rekursiven Algorithmus * Die Operation setzt voraus, dass key ungleich null ist. */ private Node getNodeRec(Comparable key, Node tree) { Node result; if (tree==null) // Baum ist leer result = null; else { int cmp = key.compareTo(tree.key); if (cmp==0) // Knoten ist gefunden result = tree; else if(cmp<0) // Suchen im linken Teilbaum result = getNodeRec(key, tree.left); else // Suchen im rechten Teilbaum result = getNodeRec(key, tree.right); } return result; } /* * Bestimmung eines Knotens, der einen vorgegebenen Schlüssel enthält * mit Hilfe eines iterativen Algorithmus * Die Operation setzt voraus, dass key ungleich null ist. */ private Node getNodeIt(Comparable key, Node tree) { Node result; result = null; Node VergleichsNode = tree; int cmp = key.compareTo(VergleichsNode.key); boolean nochwaszutun = true; //Hilfsvariable für die Schleife if(this.root==null)//Baum ist leer {} else { /** * Solange nochwaszutun=true ist führt er die Schleife aus * Er vergleicht nach und nach die Knoten. * Ist der Schlüssel sofort am Anfang 0, ist die Wurzel * der gesuchte Knoten. * * Nach dem gleichen Verfahren wird im rechten und linken * Teilbaum verfahren. * * Ist nochwaszutun=false bricht die Schleife ab. */ while(nochwaszutun) { if(cmp==0) //gefunden!! { result = VergleichsNode; nochwaszutun=false; } if(cmp<0) //Suche im linken Teilbaum falls dieser existiert //ansonsten bricht er ab { if(VergleichsNode.left==null) { nochwaszutun=false; } else { VergleichsNode=VergleichsNode.left; } } if(cmp>0) //Suche im rechten Teilbaum falls dieser existiert //ansonsten bricht er ab { if(VergleichsNode.right==null) { nochwaszutun=false; } else { VergleichsNode=VergleichsNode.right; } } } } // Hier Lösung einfügen return result; } /** * Bestimmung des Wertes zu einem vorgegebenen Schlüssel */ Object get(Comparable key) { Object result = null; if (key!=null) { Node p = getNodeIt(key, this.root); if (p!=null) result = p.value; } return result; } /** * Überprüfung, ob ein zu o inhaltsgleiches Objekt als Werte-Objekt * enthalten ist */ boolean containsValue(Object o) { boolean result=false; [color=red]//Hier Lösung einfügen [/color] } /* * Rekursives Verfahren zum Einfügen eines Paares (key,value) * in den Binärbaum mit dem Wurzelknoten tree. * Ist der Schlüssel key schon vorhanden, wird der alte * Wert durch den Wert value ersetzt. * Als Ergebnis wir ein Baum zurückgeliefert, der das * Paar (key, value) enthält. */ private Node insertNode(Comparable key, Object value, Node tree) { if (tree==null) { // Neuen Knoten erzeugen tree = new Node(key, value); this.size++; } else { int cmp = key.compareTo(tree.key); if (cmp==0) { // Alter Wert wir durch neuen Wert ersetzt tree.value = value; } else if(cmp<0) // Einfügen im linken Teilbaum tree.left = insertNode(key, value, tree.left); else // Einfügen im rechten Teilbaum tree.right = insertNode(key, value, tree.right); } return tree; } /** * Einfügen eines Paares (key,value) in den Binärbaum * Ist der Schlüssel key schon vorhanden, wird der alte * Wert durch den Wert value ersetzt. */ void put(Comparable key, Object value) { if (key!=null && value!=null) this.root = insertNode(key, value, this.root); } /* * Bestimmung des Elternknotens des symmetrischen Nachfolgers * des Knotens tree * * Der symmetrische Nachfolger eines Knotens, ist der Knoten * mit dem kleinsten Schlüssel, der größer als der Schlüssel * des Knotens tree ist. * Dieser ist der am weitesten links stehende Knoten im rechten * Teilbaum des Knotens tree. */ private Node parentSymSucc(Node tree) { Node result; result = tree; if (result.right.left!=null) { result = result.right; while (result.left.left!=null) result = result.left; } return result; } /* * Rekursives Verfahren zum Entfernen eines Knotens zu einem * vorgegebenen Schlüssel im Binärbaum mit dem Wurzelknoten tree. * Als Ergebnis wir ein Baum zurückgeliefert, der den Schlüssel * key nicht mehr enthält. */ private Node removeNode(Comparable key, Node tree) { if (tree!=null) { int cmp = key.compareTo(tree.key); if (cmp<0) // Entfernen im linken Teilbaum tree.left = removeNode(key, tree.left); else if (cmp>0) // Entfernen im rechten Teilbaum tree.right = removeNode(key, tree.right); else { // zu entfernender Knoten gefunden this.size--; if (tree.left==null) tree = tree.right; // Fall 1: siehe Skript else if (tree.right==null) tree = tree.left; // Fall 2: siehe Skript else { // Knoten besitzt zwei Kindknoten Node p = parentSymSucc(tree); if (p==tree) // Fall 3: siehe Skript { tree.key = p.right.key; tree.value = p.right.value; p.right = p.right.right; } // Fall 4: siehe Skript else { tree.key = p.left.key; tree.value = p.left.value; p.left = p.left.right; } } } } return tree; } /** * Entfernen eines Eintrags im Binärbaum zu einem vorgegebenen Schlüssel */ void remove(Comparable key) { if (key!=null) this.root = removeNode(key, this.root); } /* * Rekursives Verfahren zur Ausgabe der Paare (Schlüssel,Wert) * sortiert nach aufsteigender Reihenfolge der Schlüsseln * durch einen Inorder-Durchlauf durch den Binärbaum */ private void inorderPrint(Node tree) { if (tree!=null) { inorderPrint(tree.left); System.out.println("("+tree.key+","+tree.value+")"); inorderPrint(tree.right); } } /** * Ausgabe der Paare (Schlüssel,Wert) sortiert nach aufsteigender * Reihenfolge der Schlüssel */ void print() { System.out.println("Liste der Einträge"); System.out.println("------------------"); inorderPrint(this.root); System.out.println(); } } Um an das inhaltsgleiche Objekt zu kommen habe ich folgendes programmiert, welches leider immer nur die ersten beiden, also die Wurzel und das Objekt danach finden. Ich denke der Fehler liegt im Detail. Hier meine Programmierung: private Node ersternode() { return this.root; } boolean containsValue2(Object o, Node tree) { boolean result=false; if(tree!=null) { containsValue2(o,tree.left); /** * Ist das Objekt links vorhanden?? */ if(tree.value.equals(o)) { result=true; } containsValue2(o,tree.right); /** * Ist das Objekt rechts? */ } return result; } boolean containsValue(Object o) { boolean result = false; Node tree=this.ersternode(); result=containsValue2(o,tree); return result; // Hier Lösung einfügen } Er läfut also von links nach rechts. Nur leider durchläuft er nicht jeden Knoten. Rude ich es im Hauptprogramm auf, findet er nur die ersten beiden. Zur Illustration hier das Hauptprogramm:

Ach so klar! Schon verstanden! Danke euch allen!!

Also wenn ich die Klammern auch setze, bekomme ich das selbe Resultat. So funktioniert es, aber ich weiß nicht warum import java.io.*; public class aufgab10 { public static void main(String args[]) throws IOException { BufferedReader din = new BufferedReader(new InputStreamReader(System.in)); int n=0; boolean prim = true; System.out.println("Bitte geben Sie die Obergrenze ein"); n = Integer.parseInt(din.readLine()); for(int i=2; i<=n; i++) { for(int j=2;j<i;j++) { if(i%j==0) { prim=false; } } if(prim==true) { System.out.println(+i); } } } }[/php] Kann mir jemand erklären, warum das so funktioniert?

Ich habe mal ein kleines Primzahlen Programm geschrieben, nur irgendwie funktioniert das nicht. Er gibt alle Zahlen aus. Hier der Code: import java.io.*; public class aufgab10 { public static void main(String args[]) throws IOException { BufferedReader din = new BufferedReader(new InputStreamReader(System.in)); int n=0; boolean prim = true; System.out.println("Bitte geben Sie die Obergrenze ein"); n = Integer.parseInt(din.readLine()); for(int i=2; i<=n; i++) { for(int j=2;j<=i;j++) { if(i%j==0) prim=false; prim=true; } if(prim==true) { System.out.println(+i); } } } } [/php] Packe ich das jedoch in eine Funktion, klappt das ganze. Ich verstehe jedoch nicht, warum das mit den beiden Schleifen nicht läuft. Hier der Code mit Funktion zum Vergleich: [php] import java.io.*; public class aufgabe10f { static boolean prim(int x) { for (int j = 2; j<x; j++) if (x%j==0) return false; return true; } public static void main(String args[]) throws IOException { BufferedReader din = new BufferedReader(new InputStreamReader(System.in)); int n=0; System.out.println("Bitte geben Sie die Obergrenze ein"); n = Integer.parseInt(din.readLine()); for(int i=2; i<=n;i++) { if(prim(i)) System.out.println(+i); } } } Ich danke euch schon mal für die Hilfe!

Da endet es auch in einer Endlosschleife, aber ich habe inzwischen die Lösung und für interessierende möchte ich sie hier präsentieren: private Node getNodeIt(Comparable key, Node tree) { Node result; result = null; // Hier Lösung einfügen Node currentNode = tree; boolean nochwaszutun=true; while (nochwaszutun) { int cmp=key.compareTo(currentNode.key); if (cmp==0) //gefunden!! { result=currentNode; nochwaszutun=false; } else if (cmp<0) //Durchsuche links { if (currentNode.left==null) { nochwaszutun=false; } else { result=currentNode.left; nochwaszutun=false; } } else { if(currentNode.right==null) { nochwaszutun=false; } else { result=currentNode.right; nochwaszutun=false; } } } return result; } Ich habe einfach eine Hilfsvariable vom Typ Boolean benutzt, um das Abbrech-Kriterium zu bestimmen.

Ja genau. Deswwegen benutzt man die compareTo Anweisung. Wenn der Schlüssel 0 ist dann entspricht der Schlüssel der Wurzel und es wurde gefunden. Ist er kleiner als 0 dann soll er nach dem gleichen Prinzip im linken Teilbaum suchen und wenn er größer als 0 ist im rechten Teilbaum suchen. Rekursiv ist es ja klar und liegt bei Bäumen sowieso auf der Hand. Iterativ würde es so oder so niemand machen, aber es ist nun mal eine Übungsaufgabe. Meine Schwierigkeit liegt halt darin, wie ich die Schleife dort einbringe. Ein Kommilitone meinte, man müsse es vielleicht mit einem Stack lösen, aber sicher sind wir uns beide nicht.

Ähm, der Baum ist vom Prof vorgegeben. Wir sollten das Programm lediglich ergänzen. Und der rekursive Aufruf funktioniert ja auch.

Hmm... irgendwie klappt das auch nicht. Es wird zu einer Endlossschleife.

Hallo, wir haben in Informatik folgende Aufgabe erhalten: Na gut, ich dachte, dass es kein Problem sein dürfte, aber irgendwie ist das bei Bäumen ein Thema für sich. Ich habe gedacht eine While-Schleife zu verwenden, aber ich weiß nciht auf was ich die beziehen soll. Ich bin echt am verzweifeln. Der Rekursive Code lautet so: private Node getNodeRec(Comparable key, Node tree) { Node result; if (tree==null) // Baum ist leer result = null; else { int cmp = key.compareTo(tree.key); if (cmp==0) // Knoten ist gefunden result = tree; else if(cmp<0) // Suchen im linken Teilbaum result = getNodeRec(key, tree.left); else // Suchen im rechten Teilbaum result = getNodeRec(key, tree.right); } return result; } Ich weiß nicht mal, wie ich anfangen soll. Trotz allem habe ich einen Ansatz, der allerdings nicht terminiert. /* * Bestimmung eines Knotens, der einen vorgegebenen Schlüssel enthält * mit Hilfe eines iterativen Algorithmus * Die Operation setzt voraus, dass key ungleich null ist. */ private Node getNodeIt(Comparable key, Node tree) { Node result; result = null; // Hier Lösung einfügen if(tree!=null) { int cmp=key.compareTo(tree.key); boolean hilfe=true; if(cmp==0) { result=tree; } else if(cmp<0) { while (hilfe) { cmp=key.compareTo(tree.left.key); } if(cmp==0) { result=tree.left; hilfe=false; } } else { hilfe=true; while(hilfe) { cmp=key.compareTo(tree.right.key); if(cmp==0) { result=tree.right; hilfe=false; } } } } return result; } Und hier der komplette Code package baum; /** * Implementierung eines binären Suchbaums * * Beachte: * Der Suchbaum ist kein ausgeglichener Baum. * Er kann durch Einfüge- und Löschoperationen zu einer * linearen Liste entarten. * * Die gespeicherten Objektreferenzen für Werte dürfen * nicht gleich null sein. * */ public class MyTreeMap { /** * Innere Klasse für die Knoten des binären Sucbaumes */ class Node { // Attribute Comparable key; // Verweis auf Schlüssel-Objekt Object value; // Verweis auf Wert-Objekt Node left; // Verweis auf linken Kindknoten Node right; // Verweis auf rechten Kindknoten // Konstruktor Node(Comparable key, Object value) { this.key = key; this.value = value; this.left = null; this.right = null; } } // Attribute (Klasse MyTreeMap) private Node root; // Verweis auf Wurzelknoten des Binärbaumes private int size; // Anzahl der Knoten des Binärbaumes // Konstruktor (Klasse MyTreeMap) /** * Erzeugung eines leeren Binärbaums */ public MyTreeMap() { this.root = null; this.size = 0; } // Operationen (Klasse MyTreeMap) /** * Bestimmung der Anzahl der Knoten im Binärbaum */ public int size() { return this.size; } /* * Bestimmung eines Knotens, der einen vorgegebenen Schlüssel enthält * mit Hilfe eines rekursiven Algorithmus * Die Operation setzt voraus, dass key ungleich null ist. */ private Node getNodeRec(Comparable key, Node tree) { Node result; if (tree==null) // Baum ist leer result = null; else { int cmp = key.compareTo(tree.key); if (cmp==0) // Knoten ist gefunden result = tree; else if(cmp<0) // Suchen im linken Teilbaum result = getNodeRec(key, tree.left); else // Suchen im rechten Teilbaum result = getNodeRec(key, tree.right); } return result; } /* * Bestimmung eines Knotens, der einen vorgegebenen Schlüssel enthält * mit Hilfe eines iterativen Algorithmus * Die Operation setzt voraus, dass key ungleich null ist. */ private Node getNodeIt(Comparable key, Node tree) { Node result; result = null; // Hier Lösung einfügen if(tree!=null) { int cmp=key.compareTo(tree.key); boolean hilfe=true; if(cmp==0) { result=tree; } else if(cmp<0) { while (hilfe) { cmp=key.compareTo(tree.left.key); } if(cmp==0) { result=tree.left; hilfe=false; } } else { hilfe=true; while(hilfe) { cmp=key.compareTo(tree.right.key); if(cmp==0) { result=tree.right; hilfe=false; } } } } return result; } /** * Bestimmung des Wertes zu einem vorgegebenen Schlüssel */ Object get(Comparable key) { Object result = null; if (key!=null) { Node p = getNodeRec(key, this.root); if (p!=null) result = p.value; } return result; } /** * Überprüfung, ob ein zu o inhaltsgleiches Objekt als Werte-Objekt * enthalten ist */ boolean containsValue(Object o) { boolean result = false; // Hier Lösung einfügen return result; } /* * Rekursives Verfahren zum Einfügen eines Paares (key,value) * in den Binärbaum mit dem Wurzelknoten tree. * Ist der Schlüssel key schon vorhanden, wird der alte * Wert durch den Wert value ersetzt. * Als Ergebnis wir ein Baum zurückgeliefert, der das * Paar (key, value) enthält. */ private Node insertNode(Comparable key, Object value, Node tree) { if (tree==null) { // Neuen Knoten erzeugen tree = new Node(key, value); this.size++; } else { int cmp = key.compareTo(tree.key); if (cmp==0) { // Alter Wert wir durch neuen Wert ersetzt tree.value = value; } else if(cmp<0) // Einfügen im linken Teilbaum tree.left = insertNode(key, value, tree.left); else // Einfügen im rechten Teilbaum tree.right = insertNode(key, value, tree.right); } return tree; } /** * Einfügen eines Paares (key,value) in den Binärbaum * Ist der Schlüssel key schon vorhanden, wird der alte * Wert durch den Wert value ersetzt. */ void put(Comparable key, Object value) { if (key!=null && value!=null) this.root = insertNode(key, value, this.root); } /* * Bestimmung des Elternknotens des symmetrischen Nachfolgers * des Knotens tree * * Der symmetrische Nachfolger eines Knotens, ist der Knoten * mit dem kleinsten Schlüssel, der größer als der Schlüssel * des Knotens tree ist. * Dieser ist der am weitesten links stehende Knoten im rechten * Teilbaum des Knotens tree. */ private Node parentSymSucc(Node tree) { Node result; result = tree; if (result.right.left!=null) { result = result.right; while (result.left.left!=null) result = result.left; } return result; } /* * Rekursives Verfahren zum Entfernen eines Knotens zu einem * vorgegebenen Schlüssel im Binärbaum mit dem Wurzelknoten tree. * Als Ergebnis wir ein Baum zurückgeliefert, der den Schlüssel * key nicht mehr enthält. */ private Node removeNode(Comparable key, Node tree) { if (tree!=null) { int cmp = key.compareTo(tree.key); if (cmp<0) // Entfernen im linken Teilbaum tree.left = removeNode(key, tree.left); else if (cmp>0) // Entfernen im rechten Teilbaum tree.right = removeNode(key, tree.right); else { // zu entfernender Knoten gefunden this.size--; if (tree.left==null) tree = tree.right; // Fall 1: siehe Skript else if (tree.right==null) tree = tree.left; // Fall 2: siehe Skript else { // Knoten besitzt zwei Kindknoten Node p = parentSymSucc(tree); if (p==tree) // Fall 3: siehe Skript { tree.key = p.right.key; tree.value = p.right.value; p.right = p.right.right; } // Fall 4: siehe Skript else { tree.key = p.left.key; tree.value = p.left.value; p.left = p.left.right; } } } } return tree; } /** * Entfernen eines Eintrags im Binärbaum zu einem vorgegebenen Schlüssel */ void remove(Comparable key) { if (key!=null) this.root = removeNode(key, this.root); } /* * Rekursives Verfahren zur Ausgabe der Paare (Schlüssel,Wert) * sortiert nach aufsteigender Reihenfolge der Schlüsseln * durch einen Inorder-Durchlauf durch den Binärbaum */ private void inorderPrint(Node tree) { if (tree!=null) { inorderPrint(tree.left); System.out.println("("+tree.key+","+tree.value+")"); inorderPrint(tree.right); } } /** * Ausgabe der Paare (Schlüssel,Wert) sortiert nach aufsteigender * Reihenfolge der Schlüssel */ void print() { System.out.println("Liste der Einträge"); System.out.println("------------------"); inorderPrint(this.root); System.out.println(); } } getNodeIt sollte dann in der get Anweisung erscheinen. Also anstatt getNodeRec jetzt getNodeIt. Allerdings funktioniert meine Idee nicht. Helft mir!

Oh man so ein einfaches Programm habe ich nicht hinbekommen. *schäm* Hier für interessierende der Programm-Code import java.io.*; public class potenzfeld { public static void main(String args[]) throws IOException { int n; int x=12; int y[]; BufferedReader din = new BufferedReader( new InputStreamReader(System.in)); System.out.print("Bitte geben Sie die Potenz ein: "); n = Integer.parseInt(din.readLine()); y=new int[x]; for (int i=2; i<x; i++) //durchläuft das Feld { y[i]=potenz(i,n); System.out.println(+y[i]); } } private static int potenz(int base, int exp) { int temp = base; if(exp == 0) { // x^0 ist 1 return 1; } for (int i = 1; i < exp; i++) { temp = temp * base; } return temp; } } Ich brauchte hier gar nicht dem Feld logischerweise nicht die Werte zuweisen. Das geschieht ja schon in der Schleife. Ich muss ihm lediglich Platz für 12 Elemente schaffen, da ja 0 bis 11. Ich durchlaufe das Feld und potenziere jedes Element von 2 bis 11 bzw. Element 12 mit Hilfe der Funktion. In der Funktion deklariere ich selbstverständlich Basis und Exponenten (das ich darauf nicht gekommen bin *schäm*). Dort überprüft er zunächst, ob der Exponent 0 ist, wenn dies zutrifft gibt er 1 zurück. Wenn nicht, dann geht er über in die Schleife, die bei 1 beginnt und bei kleiner als exponent aufhört. Bei 2 führt er also das ganze nur einmal durch. Dort mulitpliziere ich die Variable temp, der ich zuerst den Wert der Basis zugewiesen habe, mit der Basis. Das Ergebnis wird in temp gespeichert und zurückgegeben. Die Funktion wird im Hauptprogramm folgendermaßen aufgerufen: y=potenz(i,n). Jetzt wird i potenziert und im Array gespeichert. Falls die Erklärung richtig ist, habe ich es verstanden!! PS: Im Grunde funktioniert java.math.pow doch nicht anders oder?

Aber ich habe es genauso gemacht, als wenn ich kein Feld hätte. Wieso macht er das? Irgendwie blicke ich da nicht durch. Probiere gleich erstmal die Funktion aus. Edit: Habe gerade die Funktion ausprobiert und sie funtkioniert. Sie geht zwar nicht bis 11, aber das bekomme ich auch noch hin. Sie geht nämlich nur bis 9. Na ja, dafür habe ich das programmieren von Funktionen und Ausführen dadurch verstanden.

Ach so. Okay, das habe ich verstanden. Jetzt muss ich nur noch herausfinden, warum das Programm bei einer Potenz von 1 und 2 richtig rechnet und ab einer Potenz von 3 nicht mehr.

Klar das Arrays von 0 beginnen, aber irgendwie verstehe trotzdem noch nicht, warum ich nicht <= schreiben darf. Dann greife ich doch nicht auf das 11. Element zu, sondern auf das 10. ,oder? Aber komischerweise nimmt er das letzte Element bei < ja mit. Doch warum weiß ich nicht. PS: Danke

Komisch bei Potenzen von 1 und 2 rechnet er richtig. Ab 3 nicht mehr. Verstehe ich nicht. Bei gibt er folgendes aus: Bitte geben Sie die Potenz ein: 3 16 81 256 625 1296 2401 4096 6561 10000 14641 Das entspräche aber der Potenz von 4. Wie kann das? Bei 2 ist alles korrekt, aber bei 3 nciht mehr. Eigentlich sollte man froh sein, dass es die java.math Klasse gibt. Denn dann sähe ein funktionierendes Programm so aus: import java.io.*; import java.math.*; public class aufgabe12 { /* entspricht nicht zu 100 % * der Aufgabenstellung * Man sollte eigentlich selbst ne Funktion schreiben * Hier geschieht es über die java.math klasse */ public static void main(String args[]) throws IOException { double Ergebnis=0; double n; BufferedReader din = new BufferedReader( new InputStreamReader(System.in)); System.out.print("Bitte geben Sie die Potenz ein "); n = Integer.parseInt(din.readLine()); // Einlesen eines Ganzzahlwertes for (int i=0;i<=11;i++) { Ergebnis=Math.pow(i,n); System.out.println("Die Zahl " +i+ " hoch " +n+ " ergibt " +Ergebnis); } } } Doch wüsste ich schon gerne wie das math.pow arbeite bzw. wie ich das programmieren kann ohne auf diese Klasse zuzugreifen.

Quatsch termininiert wohl, habe nur die Programmausgabe vergessen. *lol* Doch ganz korrekt ist es noch nicht. Der gibt mir bei einer Eingabe von Potenz 4 folgendes aus: Bitte geben Sie die Potenz ein: 4 256 6561 65536 390625 1679616 5764801 16777216 43046721 100000000 214358881 Die Werte sind ein wenig zu hoch, denke ich. Ach ja benutze ich anstatt der zweiten For-Schleife eine while - Schleife mit folgendem Code while(n!=1) { y[i]=potenz(y[i]); n--; } Dann errechnet er mir nur den ersten Wert im Array, also er rechnet nur 2 hoch n. Warum? Er müsste doch genauso durchlaufen, oder nicht?

Also bei <x terminiert das Programm nicht. Und es sind ja 10 Elemente. Es geht ja von 2 bis 11, also 10. Bin schon richtig verzweifelt. Wenn ich schon so ein einfaches Prog nicht hinbekomme...

Hallo, wir hatten als Aufgabe ein Programm in Java zu schreiben, das eine eingegebene Zahl n die Potenzen 2 hoch n, 3 hoch n bis 11 hoch n berechnet, die Ergebnisse in einem Array speichert und diesen Array dann ausgibt. Wir sollten zur Berechnung eine Funktion verwenden. Ich habe schon ein wenig "gebastetlt" bekomme es aber nicht hin. Das ganz soll ohne Java.math laufen. Hier, was ich bisher geschrieben habe: import java.io.*; public class potenzfeld { public static void main(String args[]) throws IOException { int n; int x=10; int y[]; BufferedReader din = new BufferedReader( new InputStreamReader(System.in)); System.out.print("Bitte geben Sie die Potenz ein: "); n = Integer.parseInt(din.readLine()); y=new int[x]; y[0]=2; y[1]=3; y[2]=4; y[3]=5; y[4]=6; y[5]=7; y[6]=8; y[7]=9; y[8]=10; y[9]=11; for (int i=0; i<=x; i++) //durchläuft das Feld { for(int j=1; j<n; j++) { y[i]=potenz(y[i]); } } } private static int potenz(int x) { int y; y=x; return y=y*x; } } Die Konsole gibt mir aber einen Fehler zurück. Dieser lautet folgendermaßen: Doch wo überschreite ich das Feld. Ich komme mir so blöd vor, das sollte doch total einfach sein. Denn wenn ich das ganze nur mit einer einzelnen Zahl machen soll bekomme ich das hin, denn dann würde der Code lediglich so lauten: import java.io.*; public class potenz { public static void main(String args[]) throws IOException { int n; int y; int z=4; System.out.println(+z); BufferedReader din = new BufferedReader( new InputStreamReader(System.in)); System.out.print("Bitte geben Sie die Potenz ein: "); n = Integer.parseInt(din.readLine()); y=z; if (n==0) y=1; if (n==1) y=z; else while(n!=1) //nicht ungleich 0! Denn dann multipliziert er einmal zuviel { y=y*z; n--; } System.out.println(+y); } } Dabei fällt mir auf, dass ich oben gar nicht die Potenzen 0 und 1 berücksichtigt habe. Aber das wäre ja das kleinere Problem, wenn ich wüsste wie ich das ganze mit einem Feld und einer Funktion löse.

Hallo, Kann mir jemand erklären, wie man den Quicksort über Dreiermedian löst? Irgendwie habe ich da überhaupt nicht das Auswahlverfahren verstanden.

Leider sind einige Algorithmen ganz schön schnell von den Animationen her dargestellt. Selbst mit der Geschwindigkeit von 1 ist es bei Insertion Sort zu schnell.

Ich wollte nur sagen, dass ich diese Seite liebe!!! Die ist super verständlich aufgemacht!!! Danke!!!

Es wird schon klarer! Ich schaue mir den ALgorithmus nochmal in Ruhe an und melde mich nochmal bei Fragen! Aber erstmal danke!!! (Bitte nicht als Spam werten! )

Also wenn r < l wäre, wären die Zeiger "aneinander vorbeigelaufen" ? Aber wieso tausche ich dann? Auch verstehe ich die Anwendung der Rekursion dort nicht.

Es ist Quicksort und der Vergleich ist anscheinend richtig. Ich habe den so in zig Büchern gefunden. Folgende Variante habe ich auch gefunden, die ich nicht verstehe: Dann habe ich noch folgende Variante auf einer Web-Seite gefunden: Könnt ihr mir den erklären?

Ich verstehe den Algorithmus ab hier nicht Helft mir! Ich stehe da komplett auf dem Schlauch! :confused: