witch doctor
-
Gesamte Inhalte
145 -
Benutzer seit
-
Letzter Besuch
Inhaltstyp
Profile
Forum
Downloads
Kalender
Blogs
Shop
Beiträge von witch doctor
-
-
Also bei mir läuft es.
Ich verstehe den Code nur nicht komplett.
Der komplette Code wäre zB so:
import java.io.*; /** * Die nachfolgende Methode führt den InsertionSort * (auch Sortieren durch Einfügen genannt) * aus. * Das Grundprinzip dieser Sortierung besteht darin, den ersten Wert einer Liste * auszuwählen und jeden weiteren an die richtige Stelle (gemäß der Sortierungsanforderung) * einzufügen. */ public class insertionsort { public static void insertionSort(int feld[]) { for(int i=0;i<feld.length;i++) //Das Feld wird durchlaufen { int marker=i; // Der Index wird hier zwischengespeichert //System.out.println("marker "+marker); int temp=feld[i]; //speichert die Eingaben zwischen //System.out.println("temp "+temp); while(marker>0 && feld[marker-1]>temp) { feld[marker]=feld[marker-1]; //hier wird getauscht marker--; System.out.println("marker "+marker); } feld[marker]=temp; //feld[marker] wird sich gemerkt; } } public static void main(String args[]) throws IOException { int n; int feld[]; BufferedReader din = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Bitte geben Sie die Feldgröße ein:"); n=Integer.parseInt(din.readLine()); feld=new int[n]; for(int i=0;i<n;i++) { System.out.println("Bitte geben Sie einen Wert ein"); feld[i]=Integer.parseInt(din.readLine()); } insertionSort(feld); for(int i=0;i<n;i++) { System.out.println(feld[i]); } } }Er sortiert aufsteigend. Und das macht er auch ganz wunderbar.
Nur zum Beispiel verstehe ich das marker-- in der for-Schleife nicht.
-
Kann mir jemand den Algorithmus zu Sortieren durch Einfügen erklären?
Ich wollte es als JAVA Programm schreiben.
Ich habe auch eine fremde Lösung gefunden, aber noch nicht so wirklich verstanden, warum da was gemacht wird:
public static void insertionSort(int feld[]) { for(int i=0;i<feld.length;i++) //Das Feld wird durchlaufen { int marker=i; int temp=feld[i]; while(marker>0 && feld[marker-1]>temp) { feld[marker]=feld[marker-1]; marker--; } feld[marker]=temp; //feld[marker] wird sich gemerkt; }Könnt ihr mir das erklären?
-
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:
Programmieren Sie in der Klasse MyTreeMap die Operationpublic boolean containsValue(Object o),
die überprüft, ob der Baum ein zu o inhaltsgleiches Objekt als Werte-Objekt enthält.
Hinweis: Um festzustellen, ob ein vorgegebener Wert in einem Suchbaum enthalten
ist, müssen im Extremfall alle Knoten des Baumes durchlaufen werden.
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:
-
Primzahlen
in Java
Ach so klar! Schon verstanden!
Danke euch allen!!
-
Primzahlen
in Java
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?
-
Primzahlen
in Java
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:
Die Klasse MyTreeMap enthält die Operation getNodeRec, die nach einem Knoten
sucht, der einen vorgegebenen Schlüssel enthält. Diese Operation benutzt einen
rekursiven Algorithmus.
Programmieren Sie in der Klasse MyTreeMap die Operation
private Node getNodeIt(Comparable key, Node tree),
die statt eines rekursiven Algorithmus eine Schleife für die Suche nach dem Knoten
verwendet. Testen Sie Ihre Operation, indem Sie in der Operation get anstatt
getNodeRec die Operation getNodeIt aufrufen.
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 Codepackage 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.
-
Also Zeta ist glaube ich saugeil!!!
Habe mir das Video angeschaut und gedacht:
Musst du haben!!!
Könnte vielleicht endlich mal schaffen Windows vom Thron zu stoßen.
-
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.
-
bei der 1. Forschleife hast "<=x" gemacht, richtig wäre aber halt "<" !
Arrays beginnen mit 0 und bei ihrer Deklaration muss du die Größe angeben!
Hier würdest du auf das 11. Element zugreifen obwohl dein Array nur für 10 reserviert ist!
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:java.lang.ArrayIndexOutOfBoundsException: 10 at potenzfeld.main(potenzfeld.java:36) Exception in thread "main"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.
-
Habe ich dran gedacht. Das Video zu Xerox habe ich mir schon gezogen.
-
oh cool danke!!
Damit kann ich was anfangen!
Sortieren durch einfügen
in Algorithmik
Geschrieben
Aha, wird schon klarer.
Dies wäre sicherlich mit einer binären Suche möglich.
Nur wie mache ich das. Den Algorithmus zur binären Suche habe ich verstanden.
Nur wie baue ich den in Sortieren durch einfügen ein?