ADT Graph nach größe Abfragen

ocsme

Top Contributor
Guten Tag,

habe einen kleinen Graph geschrieben der eine Innere Klasse Node hat. Jetzt möchte ich sehr gerne das Node mir die Anzahl der Knoten zurück gibt mit denen der Knoten verbunden ist.
Des weiteren soll ich/möchte ich eine Methode im Graph schreiben die mir die gesamte Anzahl der Zusammenhangskomponenten des Graphen zurück gibt als ArrayList<Integer>.

Mein Programm sieht derzeit so aus:
Java:
import java.util.*;

public class Graph {
    
    static class Node {
        
        int element;
        Node() {
            
        }
        
        Node(int i) {
            element=i;
        }
        
        List<Node> adjacencylist = new ArrayList<>();
        boolean mark = false;
        
        public int size() {
            return adjacencylist.size()+1;
        }
        
        public String toString() {
            return element+"";
        }
    }
    
    private List<Node> nodes = new ArrayList<>(); //soll eigentlich ein Set genutzt werden! wollte es aber erst mal mit einer Liste versuchen
    
    public boolean insert(Node element) {
        if(nodes.add(element))
            return true;
        return false;
    }
    
    public boolean addEdge(Node a, Node b) {
        if(a.adjacencylist.add(b))
            return true;
        return false;
    }
    
    public void output() {
        for( Node n : nodes) {
            if(n.adjacencylist != null)
                System.out.println(n+"->"+n.adjacencylist);
            else System.out.println(n);
        }
    }
    
    
    public String toString() {
        return nodes.toString();
    }
    
    public static void main(String[] args) {
        
        Graph g = new Graphh();
        Graph.Node n1 = new Node(1);
        Graph.Node n2= new Node(2);
        Graph.Node n3 = new Node(3);
        Graph.Node n4 = new Node(4);
        Graph.Node n5 = new Node(5);
        Graph.Node n6 = new Node(6);

        System.out.println(g.insert(n1));
        System.out.println(g.insert(n2));
        System.out.println(g.insert(n3));
        System.out.println(g.insert(n4));
        System.out.println(g.insert(n5));
        System.out.println(g.insert(n6));
        System.out.println(g.addEdge(n1, n2));
        System.out.println(g.addEdge(n1, n3));
        System.out.println(g.addEdge(n2, n1));
        System.out.println(g.addEdge(n2, n3));
        System.out.println(g.addEdge(n3, n1));
        System.out.println(g.addEdge(n3, n2));
        System.out.println(g.addEdge(n4, n5));
        System.out.println(g.addEdge(n5, n4));
        System.out.println(g);
        g.output();
        
        int size = n1.size();
        System.out.println(size);
        
    }

}

Nun meine Frage dazu.
Ist size() korrekt? Ich bekomme ja die Anzahl eines Knotens zurück :)
Und wie bekomme ich im Graph nun eine Methode hin die erkennt das die Knoten 1,2 und 3 zusammen einen Graph ergibt, Knoten 4 und 5 einen Graph und 6 ein Knoten = 1 Graph für sich. Die Anzahl der Knoten dann als Liste also so z. B. (3,2,1) <- ein Graph mit 3 Knoten ein Graph mit 2 Knoten ein Graph mit 1 Knoten.

Ich vermute es wäre leichter wenn man den Knoten selbst wieder am Anfang speichern würde in der adjacencylist damit könnte man doch überprüfen ob für jeden Knoten die adjacencylist gleich wäre und damit weiß man das sind die selben Graphen, oder vergesse ich hier Theoretisch mal wieder etwas?
Das Thema mit den AbstraktenDatenTypen ist noch nicht so meins doch ich gebe mir MÜHE :)

Vielen Dank schon mal für die Antworten :)

Liebe Grüße
 

ocsme

Top Contributor
An welchen Eigenschaften kannst Du das denn festmachen?

Das ist auf dem Übungszettel so gemacht :) oder meintest du etwas anderes?


Kommt darauf an, was size() liefern soll.
Entwickeln Sie die Methode s i z e ( ) der Klasse Nod e , die ermittelt, wie viele Knoten
die Zusammenhangskomponente umfasst, zu der der aktuelle Knoten gehört.


ize() müsste auf ein Attribut oder eine rekursive Funktion zurückgreifen...
mhhh.. die Knoten sind aber doch jeweils abgespeichert im Datenelement des jeweiligen Knotens :) deswegen dachte ich mir es wäre so leicht.
Was ich nur nicht verstehe ist auch der boolean der gegeben ist :p

LG
 
X

Xyz1

Gast
Ok, von vorne anfangen... Ist dein Graph ein so genannter DAG? Weil dann wäre eine "Zusammenhangskomponente" eines Knotens eindeutig definiert. Genauer: Für jeden Knoten lässt sich seine Zusammenhangskomponente genau angeben... Außerdem gilt wahrscheinlich: n1!=n2=>zk(n1)!=zk(n2).
 
X

Xyz1

Gast
Ok, von vorne anfangen... Ist dein Graph ein so genannter DAG? Weil dann wäre eine "Zusammenhangskomponente" eines Knotens eindeutig definiert. Genauer: Für jeden Knoten lässt sich seine Zusammenhangskomponente genau angeben... Außerdem gilt wahrscheinlich: n1!=n2=>zk(n1)!=zk(n2).
Ach Quatsch, alles wieder streichen! Diese Eigenschaft würd (nur) für einen bin tree gelten...

Bearbeitung: Was ich gerad seltsam finde, ist, dass der Begriff der Zusammenhangskomponente eigentlich nur mit ungerichteten Graphen auftaucht...
 
Zuletzt bearbeitet von einem Moderator:

ocsme

Top Contributor
Ja sry mein Fehler denn auf dem Bild sieht man einen ungerichteten Graph.
Naja dann habe ich echt Null Plan denn dann ist mein insert auch Käse!
mhhh...

LG
 

ocsme

Top Contributor
Ein ungerichteter Graph G heißt zusammenhängend, wenn es von jedem Knoten u zu jedem anderen Knoten v mindestens einen Weg gibt. Ein maximaler zusammenhängender Teilgraph eines ungerichteten Graphen G heißt Zusammenhangskomponente von G.

Muss ich dort Tiefensuche anwenden und den boolean meine Markierung dann auf True setzen wenn der Knoten bearbeitet wurde?
Dann hätte ich das ganze wieder total falsch verstanden :(
LG
 

ocsme

Top Contributor
Zyklen! Speicherst Du zu jeder Kante auch ihre "Umkehrkante"?

Das müsste ich bei addEdge noch ändern, so dass ich bei jedem einfügen einer Kante bei beiden Knoten eben die Kante einzeichne :D hört sich komisch an :D

Das hört sich vernünftig an. Wenn die Suche beendet ist, hängen die markierten Knoten zusammen...

Ich hab mal wieder viel zu doof gedacht. bzw. wir haben ja ein stück code vorgegeben bekommen da dachte ich eben es wäre mit dem Abfragen von ArrayList.size() getan :p

Werde das ganze später mal versuchen :)
Danke fürs erste :)

LG
 
X

Xyz1

Gast
Also alle Zusammenhangskomponenten printen:
Java:
import java.util.ArrayList;
import java.util.HashSet;

public class Node {
    String s = "";
    ArrayList<Node> children = new ArrayList<>();

    Node(String s) {
        this.s = s;
    }

    Node addChild(Node n) {
        children.add(n);
        n.children.add(this);
        return this;
    }

    @Override
    public String toString() {
        return s;
    }

    void size() {
        size(this, new HashSet<>());
        System.out.println("");
    }

    static void size(Node n, HashSet<Node> s) {
        if (!s.contains(n)) {
            s.add(n);
            System.out.print(n + ", ");
            for (Node node : n.children) {
                size(node, s);
            }
        }
    }

    public static void main(String[] args) {
        Node a = new Node("a");
        Node b = new Node("b");
        Node c = new Node("c");

        Node d = new Node("d");
        Node e = new Node("e");

        Node f = new Node("f");

        a.addChild(b);
        a.addChild(c);
        b.addChild(c);

        d.addChild(e);

        f.size();
        e.size();
        d.size();
        c.size();
        b.size();
        a.size();
    }
}

Dieses HashSet ist dafür da, dass das Programm i wann anhält...
 

ocsme

Top Contributor
@Tobias-nrw vielen Lieben Dank erst einmal :)
Hab es mir nicht angeschaut will es selbst lösen :) wenn ich es nicht hin bekomme schau ich mal drauf und wenn mir das später dann nichts nützt frag ich nochmal nach OKAY :)

Hättest das ganze auch in Spoiler Verpacken können :) Nicht falsch verstehen :) ist echt Lieb bin dir auch sehr Dankbar :) aber da muss ich erst einmal selber durch :p

Hab später auch noch einen Iterator :p schon wieder :D Ich hab einfach oft das Problem zu erkennen was gefragt ist und lasse mich zu schnell und einfach in die Irre führen :(

LG
 

ocsme

Top Contributor
So hab es versucht und bekomme es nicht hin. Mir fehlt immer 1 Knoten :(
Code:
public int size() {
            return size(this,0);
        }
      
        private int size(Node n, int c) {
            for(Node a : n.adjacencylist)
                if(!a.mark) {
                    c ++;
                    a.mark = true;
                    return size(this,c);
                }
            return c;
        }

Ich glaube was mir jetzt eingefallen ist, das mir der Knoten an sich mit dem ich rein gehe fehlt! Oder?
Hab mir das ganze so gedacht:
a.size() -> suche in der adjacencliste von a und schaue ob mark auf false steht. Das wäre bei a der Knoten b. Nun wird dieser auf mark = true gesetzt und count++. Schaue in b die adjacencliste dort steht ja a und c drin. Nehmen wir nun den Knoten c also c mark = true und count++. Nun sollte er noch einmal dort rein schauen und mir bei a mark auf true setzen und den count++ somit = 3 setzen?
Wo ist der Gedankenfehler oder Codefehler??

Meine addEdge von oben habe ich auch geändert zu:
Java:
    public boolean addEdge(Node a, Node b) {
        if(a != null && b != null) {
            a.adjacencylist.add(b);
            b.adjacencylist.add(a);
            return true;
        }
        return false;
    }

Muss ein Denkfehler auch haben den System.out.println(n1.mark); gibt mir false zurück :( wenn ich n1.size() aufrufe!
 

ocsme

Top Contributor
Man sollte sich auch mal die Nodes ausgeben lassen :p

der return stimmt ja auch nicht :p

Java:
public int size() {
            return size(this,0);
        }
       
        private int size(Node n, int c) {
            for(Node a : n.adjacencylist)
                if(!a.mark) {
                    System.out.println(a);
                    c ++;
                    a.mark = true;
                    return size(a,c);
                }
           
            return c;
        }


Jetzt ist auch der Knoten dabei wo die adjacencliste leer ist doch ich verstehe nicht mehr wieso kann die Methode mir hier c zurück geben? Dort sollte ich doch nie hin kommen können oder?? Ufff...
Java:
        public int size() {
            return size(this,0);
        }
        
        private int size(Node n, int c) {
            if(n!=null) {
                if(!n.adjacencylist.isEmpty()) {
                    for(Node a : n.adjacencylist)
                        if(!a.mark) {
                            c ++;
                            a.mark = true;
                            return size(a,c);
                        }
                }
                else {
                    n.mark = true;
                    return 1;   
                }
            }
            else return 0;
            return c;
        }
 
Zuletzt bearbeitet:

Meniskusschaden

Top Contributor
@ocsme: Welche Variante davon ist denn nun dein aktueller Lösungsvorschlag?
So hab es versucht und bekomme es nicht hin. Mir fehlt immer 1 Knoten :(
Wie kommst du darauf? Bei deinem Beispielgraphen (in der ursprünglichen Einfügereihenfolge) funktioniert es. Allerdings leider nur zufällig. Wenn du z.B. eine Kante zwischen a und f einfügst, geht es schief.
a.size() -> suche in der adjacencliste von a und schaue ob mark auf false steht. Das wäre bei a der Knoten b. Nun wird dieser auf mark = true gesetzt und count++. Schaue in b die adjacencliste dort steht ja a und c drin. Nehmen wir nun den Knoten c also c mark = true und count++. Nun sollte er noch einmal dort rein schauen und mir bei a mark auf true setzen und den count++ somit = 3 setzen?
Wo ist der Gedankenfehler oder Codefehler??
Der Ablauf ist nicht so, wie du ihn beschreibst. Die rekursiven Aufrufe für a sehen so aus:
Code:
size(a, 0)
.size(b, 1)
..size(a, 2)
...size(c, 3)
 

ocsme

Top Contributor
wie das rekursiv geht geschweige den wie Tiefensuche oder Breitensuche Funktioniert weiß ich nicht und bekomme es auch nicht hin.
Normalerweise sollte man bei dieser Aufgabe das ganze doch so gelöst bekommen:
Ich rechne +1 am Anfang das ist der Knoten der aufgerufen wird, dann laufe ich nur durch die Liste und markiere die Knoten die ich besucht habe und zähle pro Knoten +1 dazu.

Java:
public int size() {
            return size(this,1);
        }
        
        private int size(Node n, int c) {
                if(!n.adjacencylist.isEmpty()) {
                    for(Node a : n.adjacencylist)
                        if(!a.mark) {
                            c ++;
                            a.mark = true;
                        }
                }
                else {
                    n.mark = true;
                    return 1;   
                }

            return c;
        }
 

Meniskusschaden

Top Contributor
wie das rekursiv geht geschweige den wie Tiefensuche oder Breitensuche Funktioniert weiß ich nicht
Deine bisherigen Ansätze waren aber rekursiv.
und markiere die Knoten die ich besucht habe
Das ist im Moment noch ziemlich nutzlos, weil du ohnehin nur die Nachbarknoten deines Startknotens aufsuchst und dann aufhörst. Da kann kein Knoten mehrfach besucht werden. Vor allem aber werden Nachbarknoten der Nachbarn des Startknotens gar nicht erreicht.
 

ocsme

Top Contributor
@Meniskusschaden du hast vollkommen recht!
Wie doof. Dann muss ich die Knoten aus der Adja-Liste vorher speichern.
Jetzt habe ich es so versucht doch leider immer noch nicht das gewünschte Ergebnis :(
Ich glaube ich brauch hierfür noch ein weiteres Leben bis ich das verstehe :(

(nicht wundern hab die Methode erstmal void gemacht)
Java:
        public void size() {
            int count = 0;
            java.util.Stack<Node> stack = new java.util.Stack<>();
            stack.push(this);
            while(!stack.isEmpty()) {
                Node tmp = stack.pop();
                if(!tmp.mark) {
                    System.out.println(count++);
                    tmp.mark=true;
                    for(Node n : tmp.adjacencylist)
                        stack.push(n);
                }
            }
            
        }
 

ocsme

Top Contributor
Das sieht vernünftig aus.

ja es geht auch :D
Hatte gestern den Fehler gemacht, das im Output die Variable ja später erneut hochgezählt werden würde.
So werden nun die Richtigen Zahlen ausgegeben.

@Meniskusschaden mein Problem ist oft das ich das ganze nicht wirklich verstehe, dann frage ich hier nach und habe eine Idee im Kopf, wie hier ja auch wieder :D bis ich verstanden habe was du bzw. die anderen meinten verging wieder viel Zeit :(
Ich muss echt die Theorie erst mal lernen :p
Aber jetzt habe ich es verstanden.

Was ich jetzt nur noch nicht verstehe ist das ist doch auch wie Tiefensuche, wo ist der Unterschied zu Tiefen und Breitensuche? Bei der Breitensuche nimmt man eine Queue dann hat man First-in First-out statt First-in Last-Out Prinzip oder so irgendwie. Ist das der einzige Unterschied?

LG
 
X

Xyz1

Gast
@ocsme Jeder musste das lernen. Das ist eigentlich nicht besonders.

Der Unterschied zwischen Tiefen- und Breitensuche macht hier keinen Unterschied. Wenn man so will, so ist DFS FILO und BFS FIFO.
 

ocsme

Top Contributor
@Tobias-nrw das stimmt wohl ich habe mich auch lange davor gedrückt.
Denn wenn ich es Programmiere (versuche) dann verstehe ich das besser als nur auf dem Papier. Denn auf dem Papier hätte ich hier z. B. so weiter gemacht und gesagt klappt doch mit der Variante nur durch die Liste zu laufen!!!

Aber nun geht es ja und ich hab wieder was hinzu gelernt :)

Danke das Ihr alle so NETT seit :) "Daumenhoch"

LG
 

Meniskusschaden

Top Contributor
Was ich jetzt nur noch nicht verstehe ist das ist doch auch wie Tiefensuche, wo ist der Unterschied zu Tiefen und Breitensuche?
Bei der Tiefensuche wird ein Pfad immer bis hinunter zum Blatt abgearbeitet, bevor die Verzweigungen abgearbeitet werden.
Bei der Breitensuche werden die Knoten ebenenweise abgearbeitet. Dein Algorithmus ist eine Tiefensuche.
Die größte Zusammenhangskomponente in deinem Beispielgraphen ist aber zu klein, um den Unterschied zwischen Breiten- und Tiefensuche zu sehen. Das müsstest du vielleicht mal mit einem stärker verzweigten Graphen durchspielen.
Bei der Breitensuche nimmt man eine Queue dann hat man First-in First-out statt First-in Last-Out Prinzip oder so irgendwie.
Wenn du eine Queue genommen hättest, wäre es eine preorder-Tiefensuche gewesen (Wurzel-links-rechts). Mit deinem Stack ist es sozusagen eine "reverse-preorder-Tiefensuche" (sofern es den Begriff gibt) geworden (Wurzel-rechts-links). Also beides keine Breitensuche.
Die Begriffe FIFO und FILO (oder gebräuchlicher LIFO) sind für die Datenstrukturen Queue und Stack zwar passend, zur Charakterisierung des eigentlichen dfs- bzw. bfs-Algorithmus meines Erachtens aber nicht gut geeignet.
 
X

Xyz1

Gast
Die Begriffe FIFO und FILO (oder gebräuchlicher LIFO) sind für die Datenstrukturen Queue und Stack zwar passend, zur Charakterisierung des eigentlichen dfs- bzw. bfs-Algorithmus meines Erachtens aber nicht gut geeignet.
Das stimmt wohl; aber nicht eindeutig, aber im Wesentlichen werden sie dadurch charakterisiert. Pre-, Post- und In-order sind "Spezialfälle" der DFS.
Wenn man so will, so ist jede DFS LIFO- und x-order -behaftet, zusammen beschreiben diese Prädikate eine DFS "eindeutig".

Und... FILO vs. LIFO... das werde ich mir nie merken.^^ :D
 

Meniskusschaden

Top Contributor
Wenn man so will, so ist jede DFS LIFO- und x-order -behaftet
Hm, nehmen wir mal folgenden Baum:
Code:
                  +-------+
                  |   4   |
                  +---+---+
                      |
          +-----------+-----------+
          |                       |
      +---+---+               +---+---+
      |   2   |               |   6   |
      +---+---+               +---+---+
          |                       |
    +-----+-----+           +-----+-----+
    |           |           |           |
+---+---+   +---+---+   +---+---+   +---+---+
|   1   |   |   3   |   |   5   |   |   7   |
+-------+   +-------+   +-------+   +-------+
Die inorder-Tiefensuche liefert 1234567. Die 1 wird also als erstes Element ausgegeben. Wo wurde die denn nun als letztes Element hinein getan?;)
 
X

Xyz1

Gast
Naja er sah 4, danach 2 und als letztes 1; dasselbe gilt dann für die sonstigen Nodes auch...
 
X

Xyz1

Gast
@Meniskusschaden Das war doch jetzt eine Fangfrage/rethorische Frage von Dir oder? Also Du hattest mich bereits verstanden, aber wolltest Selbiges bei mir testen oder? So leicht bin ich aber nicht zu durchschauen. :D Aber es fragt sich, inwiefern diese Diskussion ihn/ihr hilft... Ich wollte ihm/ihr lediglich passende Suchbegriffe an die Hand geben, damit er/sie sich damit weiter auseinandersetzen kann. Deine Absicht hingegen ist mir nicht ersichtlich.
 

ocsme

Top Contributor
Ich danke euch nochmals und habe gleich eine Frage die jetzt zwar hier von abweicht doch ich finde auch unter google nichts.
Wenn nicht muss ich ein neues Thema aufmachen schon wieder!

Was ist die korrekte lineare Präfix-Repräsentation eines Binärbaumes? :p sry vom Thema abkommen.

PS: zum Thema oben bis zum Thema Tiefen und Breitensuche kam ich noch mit danach bin ich ausgestiegen? :eek:
da muss endlich die Theorie nachgearbeitet werden ;)

Nochmals vielen Lieben Dank an euch
 

Meniskusschaden

Top Contributor
@Meniskusschaden Das war doch jetzt eine Fangfrage/rethorische Frage von Dir oder?
Eigentlich war es nur als Hinweis gedacht, weil ich die LIFO/FIFO-Terminologie eher verwirrend finde, wenn man die Eigenschaften des eigentlichen Algorithmus betrachtet. Beim Stack beschreibt LIFO ja exakt was man als Benutzer eines Stacks beobacht. Bei einer Queue und FIFO ebenfalls. Bei der Traversierung durch einen Graphen sind das aber nur Implementierungsdetails der verwendeten Hilfsdatenstrukturen. Ich finde, das ist nicht die passende Abstraktionsebene und tritt aus der Perspektive des Benutzers nicht wirklich in Erscheinung.
Gegen die Aussage, dass eine LIFO-Datenstruktur bei der Implementierung einer Tiefensuche nützlich ist, hätte ich aber nichts einzuwenden.;)
Was ist die korrekte lineare Präfix-Repräsentation eines Binärbaumes?
Ich denke, damit ist das Ergebnis einer preorder-Tiefensuche gemeint. In meinem Beispielbaum aus #35 wäre das 4213657
 

ocsme

Top Contributor
Also die ganz normale Pre-Order Traversierung mit Wurzel, Links, Rechts.
bzw. ganz normal ist hier ja auch wieder falsch denn durch den Stack der Intern aufgebaut wird absolviert er ja eine Tiefensuche oder habe ich das falsch verstanden?
Die Anordnung wann ich den Knoten zuerst ausspucke oder etwas mit dem Knoten mache ist beliebig somit kommen wir auf Inorder, Preorder und Postorder doch das sind nur Varianten der Tiefensuche.

Wenn das jetzt auch wieder Falsch ist dann laufe ich heute gegen die Wand !!! :D

LG
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
M Untersuchen ob ein Graph nach entfernen einer Kante immer noch zusammenhängend ist Java Basics - Anfänger-Themen 70
Q Tiefensuche Graph -> Schulprojekt Java Basics - Anfänger-Themen 1
F Graph Tiefensuche Methode Java Basics - Anfänger-Themen 7
S Längster Pfad zwischen zwei Vertices in einem Graph Java Basics - Anfänger-Themen 3
danieldemetry Java - Graph Komponenten - Ausgabe Java Basics - Anfänger-Themen 0
N gerichteter Graph aus einer Datei einlesen Java Basics - Anfänger-Themen 21
Z Graph einlesen Java Basics - Anfänger-Themen 2
S Ungerichteter Graph in Java Java Basics - Anfänger-Themen 1
M int double int double Graph Java Basics - Anfänger-Themen 3
A Tiefensuche in Graph Java Basics - Anfänger-Themen 4
N gerichteten Graph abspeichern Java Basics - Anfänger-Themen 2
Luk10 Frage zu Graph Tiefensuche Java Basics - Anfänger-Themen 4
S Methoden Wegsuche in einem Graph Java Basics - Anfänger-Themen 6
F Zusammenhängend Komponente suchen(Graph) Java Basics - Anfänger-Themen 4
F Kanten in Graph Java Basics - Anfänger-Themen 3
M Wth? übernimmt nichtübergebenen Wert (Graph) Java Basics - Anfänger-Themen 4
T Wie kann ich einem Graph in nem JPanel eine fixe Größe geben? Java Basics - Anfänger-Themen 6
H gerichteter Graph Java Basics - Anfänger-Themen 9
B Graph aus 2dim-Array Java Basics - Anfänger-Themen 3
D Map<String, Integer> sortieren und der reinfolge nach die Glieder abfragen Java Basics - Anfänger-Themen 3
S nach Import von jars (PLC4x) in Eclipse kann nicht mehr compiliert werden Java Basics - Anfänger-Themen 9
S Java: Wie sortiere ich eine ArrayList benutzerdefinierter Objekte nach einem bestimmten Attribut? Java Basics - Anfänger-Themen 2
M Queue-Datenstruktur: nach dem Elementen entfernen, das Ergebnis ist immer noch nicht optimal. Java Basics - Anfänger-Themen 3
N Hey Leute und zwar versuche ich gerade ein 2D Spiel zu Programmieren aber die Figur will sich nicht nach links oder rechts bewegen :( Java Basics - Anfänger-Themen 12
H Liste nach String-Länge sortieren Java Basics - Anfänger-Themen 1
I Bild richtig speichern / Hochkant im File Explorer, nach Upload vertikal Java Basics - Anfänger-Themen 9
D Wie kann man in Java nach Arrays auf Duplikate prüfen Java Basics - Anfänger-Themen 12
C Probleme mit Byte konvertieren nach int Java Basics - Anfänger-Themen 10
T sortierung der eingabe nach größe Java Basics - Anfänger-Themen 5
G Bei dynamischer Arrayliste nach jeder Auswahl Zahl entfernen Java Basics - Anfänger-Themen 3
ptcho Werte/Position nach dem Funktionsaufruf tauschen? Java Basics - Anfänger-Themen 1
K Warum wird mir hier nach dem ersten Durchlauf zwei mal "welchen Datentyp wollen sie übergeben?" ausgegeben ? Java Basics - Anfänger-Themen 1
H Cast von Float nach String klappt nicht Java Basics - Anfänger-Themen 12
W LocalDate toString und nach Split falsch "erkannt"? Java Basics - Anfänger-Themen 8
B Array nach Elementwerten sortieren? Java Basics - Anfänger-Themen 1
S Größte Zahl nach Eingabe der Zahl 0 ausgeben Java Basics - Anfänger-Themen 6
I Java Mail Timeout erst nach rund 5 Minuten? Java Basics - Anfänger-Themen 9
FireHorses Einen Command erst nach einer Chateingabe aktivieren Java Basics - Anfänger-Themen 1
izoards Sortier Algorithmus für Bounding Box Elememte Links nach Rechts und von Oben nach Unten Java Basics - Anfänger-Themen 33
Jambolo Karten sortieren nach Rang und Farbe Java Basics - Anfänger-Themen 5
Lion.King Subtraktion nach Eingabe im Terminal Java Basics - Anfänger-Themen 7
D Programmieren nach UML Java Basics - Anfänger-Themen 2
rosima26 Java nach letzter Ziffer sortieren Java Basics - Anfänger-Themen 19
H Kompliziertes Sortieren einer ArrayList mit Objekten(Sortieren nach X und Y) Java Basics - Anfänger-Themen 11
H Erste Schritte Nach einer Zahl n soll n Mal der String untereinander ausgegeben werden Java Basics - Anfänger-Themen 3
volcanos List & ArrayList nach Familiennamen abfragen Java Basics - Anfänger-Themen 57
sserio Wie kann man nach einer Klasse fragen? Java Basics - Anfänger-Themen 12
S Java Client-je nach Heap Size Größe startet Applikation oder nicht Java Basics - Anfänger-Themen 4
A String split funktioniert nicht, wenn mehr als 1 Ziffer vor dem Zeichen steht nach dem er trennen soll? Java Basics - Anfänger-Themen 4
F Suche nach betreuender Person für eine Jahresarbeit der 12. Klasse. Java Basics - Anfänger-Themen 6
F nach Methode Programm nicht beenden Java Basics - Anfänger-Themen 9
E Umlaute und Sonderzeichen werden nach der Build Project nicht richtig angezeigt Java Basics - Anfänger-Themen 2
M Bei nach oben scrollen soll Seite aktualisiert werden (Userscript mit Javascript) Java Basics - Anfänger-Themen 10
K log4j nach log4j2 überführen Java Basics - Anfänger-Themen 0
javapingu Jeglichen Inhalt einer Textdatei nach Zeile n löschen Java Basics - Anfänger-Themen 8
J Nach dem Exportieren funktioniert mein Programm nicht mehr Java Basics - Anfänger-Themen 8
P Datei einlesen, nach Begriff filtern und in Datei ausgeben. Problem Standardausgabe über Konsole Java Basics - Anfänger-Themen 19
B Array nach Wert prüfen rekursiv Java Basics - Anfänger-Themen 5
CptK For-Schleife in Thread nach jedem Durchlauf pausieren Java Basics - Anfänger-Themen 35
D Primzahlen Rechner nach Eratostenes von Kyrene Algorithmus Java Basics - Anfänger-Themen 2
rafi072001 Sortieren einer HashMap nach Values Java Basics - Anfänger-Themen 2
L Zahlungen nach Monat filtern Java Basics - Anfänger-Themen 2
J Jtable Eingabe nach Klick ausserhalb der Tabelle übernehmen Java Basics - Anfänger-Themen 6
I String nach Wort suchen Java Basics - Anfänger-Themen 6
C ArrayList sortieren nach bestimmten Buchstaben in den Wörtern Java Basics - Anfänger-Themen 13
javaluke Erste Schritte Array nach Datentyp sortieren Java Basics - Anfänger-Themen 16
D Methoden nach einer bestimmten Reihenfolge ausführen. Java Basics - Anfänger-Themen 20
idontknow707 Matrix nach z.B. Variable durchsuchen Java Basics - Anfänger-Themen 4
O 2D-Array nach einer Spalte sortieren Java Basics - Anfänger-Themen 22
I Liste gruppieren nach Monat? Java Basics - Anfänger-Themen 5
P Ein Objekt nach einem String durchsuchen? Java Basics - Anfänger-Themen 7
M Nach einer erstmaligen Eingabe, eine zweite Eingabe nur noch gegen bestätigung möglich Java Basics - Anfänger-Themen 2
D Input/Output fehlerhafter Algorithmus zum Ersetzen von Array-Werten nach logischem Schema Java Basics - Anfänger-Themen 1
C Meldung einer Klasse nach "oben" Java Basics - Anfänger-Themen 6
B Nach eingefügtem Code erkennt Compiler keine Instanzvar und meldet SyntaxError Java Basics - Anfänger-Themen 2
newcomerJava Nach doppelter Zahl eine Ausgabe Java Basics - Anfänger-Themen 10
M Anzahl Schleifendurchgänge nach x Sekunden anzeigen Java Basics - Anfänger-Themen 2
C Lotto 3, 4, 5, 6 Richtige nach x Ziehungen ermittelt.. Java Basics - Anfänger-Themen 7
G Primzahlen von Rekursiv nach Iterativ Java Basics - Anfänger-Themen 6
F JMenuItem Kann nicht nach einem String benannt werden... Java Basics - Anfänger-Themen 11
R JDK installieren Durcheinander nach installation von SE 14.02 Java Basics - Anfänger-Themen 6
P Sortieren von Listen nach Attributen Java Basics - Anfänger-Themen 3
B DateTimeFormatter nach LocalDateTime, wenn dd.MM.yyyy oder dd.MM.yyyy mm:hh Java Basics - Anfänger-Themen 5
1 main-Methode erweitern, Nachfrage nach wiedeholung Java Basics - Anfänger-Themen 2
G unklares Verhalten nach Instanzierung neuer Klasse Java Basics - Anfänger-Themen 3
S Wohin kommt das „abstract“? Vor oder nach „public“/ „private“ /... Java Basics - Anfänger-Themen 3
S Datenbank Befehl nach Login Java Basics - Anfänger-Themen 5
N Operatoren Schreibtischtest der Reihen-Suche nach Aufschluss in die Basics Java Basics - Anfänger-Themen 1
B Umstieg von C# nach Java Java Basics - Anfänger-Themen 18
Ellachen55 Wie nach häufigste Werte im Array suchen? Java Basics - Anfänger-Themen 2
N Wörter und Zahlen nach speziellen Wörtern ausgeben Java Basics - Anfänger-Themen 11
M Werte ändern sich nicht mehr nach Reset Java Basics - Anfänger-Themen 14
B Nach dem kompilieren werden Bilder nicht mehr gefunden Java Basics - Anfänger-Themen 10
X Nach einem Bruch testen ob es eine ganze Zahl ist Java Basics - Anfänger-Themen 6
B String nach erstem Leerzeichen trennen Java Basics - Anfänger-Themen 7
N Speichern von Werten in Variablen nach Schließen des Programms Java Basics - Anfänger-Themen 3
G String wird nach Einlesen aus Datei nicht erkannt Java Basics - Anfänger-Themen 3
CptK Best Practice Algorithmus nach jedem Schritt zum Visualisieren pausieren Java Basics - Anfänger-Themen 3
O zwei Arrays nach Werten durchsuchen und zusammenfügen Java Basics - Anfänger-Themen 3
M Double Wert nach n abschneiden ohne zu runden Java Basics - Anfänger-Themen 1

Ähnliche Java Themen

Neue Themen


Oben