Java: Arrays auslesen, speichern und vergleichen?!

Page 2 of 2 1 2
09/29/2011 15:48 Belur#16
Musste die markierte Stelle in der If Schleife beim schuelerArray nicht vin i zu j geändert werden?!
Ist mir grad mal so aufgefallen. Oder versteh ich das falsch?

PHP Code:
public  void checkAnzahlUeberschneidungen(){
                  int anzahlUeberschneidungen = 0;
                 
                  for (int i = 0; i < lehrerArray.length; i++) {
                        for (int j = 0; j < schuelerArray.length; j++) {
                                if(lehrerArray[i].vorname.equals(schuelerArray[i -> j?].vorname)){
                                        anzahlUeberschneidungen++;
                                        break;
                                }
                        }
                  }
                 
                  System.out.println("Es gibt " + anzahlUeberschneidungen + " überschneidungen.");
        } 
Ich hab beim Testen immer die gleiche Anzahl Schüler wie Lehrer genommen daher lief das auch immer bis eben im Unterricht wo ich mal zwei verschiedene genommen hab. Deswegen frag ich.





Und noch eine Frage wegen dem break; mal.
Wenn man das break weglässt kriegt man ja unnormal hohe Übereschneidungen raus.
Aber könnte man das nicht eigentlich weglassen?


Immerhin beendet sich die Schleife ja soweiso wenn j = schuelerArray.length. Also eig dann wenn alle Array Einträge abgearbeitet wurden.

Wofür dann nochmal beenden über das break?

Das klappt zwar ohne das break nicht, das ist mir auch aufgefallen. Aber ich weiß nicht genau warum. Und meine Info Lehrer wusste es auch nicht, was mich dann doch bisschen schockiert hat :awesome:
09/29/2011 16:21 Obilee#17
Ja die Indexvariable vom schueler Array muss j sein und nicht i. Hatte mich da verschrieben.

Natürlich muss das Break vorhanden sein, wir wollen doch überprüfen wieviel Überschneidungen es gibt im Allgemeinen gibt.

Nehmen wir jetzt die Tabelle Lehrer = Hans, Peter und Schüler = Hans, Hans, Müller

Wir nehmen in der ersten for-schleife den nahmen "Hans" von der tabelle lehrer und prüfen die mit dem ersten Eintrag von Schueler, also auch "Hans" den wir aus der zweiten Schleife nehmen => Es gibt eine überschneidung, der counter wird +1 gerechnet. Wir brechen die zweite schleife ab, die erste schleife nimmt jetzt den nächsten namen "Müller" aus der Tabelle lehrer und prüft jetzt wieder vom schueler index 0 die namen bis zum ende der tabelle. Da es keine überschneidung gibt wird der counter nicht +1 gerechnet.

Wenn wir jetzt das break rausnehmen wird er beim ersten mal wieder den namen "Hans" aus der tabelle der lehrer nehmen und mit dem ersten namen aus schüler vergleichen => counter +1 , da wir jetzt kein break haben nimmt er den nächsten namen aus schueler raus um den zu vergleichen, da der zweite name wieder hans ist wird der counter nochmal +1 gerechnet. Somit hätten wir schon hier alleine am Ende die ausgabe es gibt 2 überschneidungen obwohl es nur 1 gibt.

das break bricht immer die schleife ab in der er sich befindet.

hoffe checkst was ich meine, lass dir einfach mit system.out die namen ausgeben die grad verglichen werden und teste es mit dem break und ohne dann sollte es klarer werden.

[Only registered and activated users can see links. Click Here To Register...] und hier habe ich geschrieben wie verhindert werden kann das z.b wenn wir bei den lehrern mehrere gleiche namen haben es keine fehlerhafte counter ausgabe gibt
09/29/2011 16:48 Belur#18
Ja ich hab mir nur gedacht, dass die Abbruchbedingung ja ist i < lehrerArray.length.

Also dass er alle Namen aus dem lehrerArray nimmt und dann die Schleife beeendet. Wir war garnicht bewusst, dass er wieder von vorne anfängt.
09/29/2011 16:55 Obilee#19
Die zweite schleife wird für jeden Namen von den Lehrern durchgeführt. Es ja eine for schleife in einer for schleife. Du musst also auf beide Bedingungen schaun.

Quote:
Abbruchbedingung ja ist i < lehrerArray.length
Das ist keine Abbruchbedingung. Er führt die schleife solange aus solang diese Bedingung erfüllt ist.
09/29/2011 17:54 Belur#20
Ohh O.o

Entweder wurde uns das falsch beigebracht oder ich hab den Namen in einen falschen Zusammenhang gebracht -.-
09/29/2011 19:13 Obilee#21
Bei jedem durchlauf wird die Bedingung geprüft, wenn sie false zurück gibt bricht sie ab. Somit geht die schleife nur solang die Bedingung wahr ist.

Sieht man doch bei nem ganz einfachen beispiel:

for(int i = 0; i < 5; i++)
system.out.println(i);

kommt: 0 1 2 3 4 raus. Wenn i < 5 die Abbruchbedingung wäre würde es ja "übersetzt" heißen: breche schleife ab wenn i kleiner als 5 ist. Aber richtig heißt es: führe die schleife solange aus wie i kleiner 5 ist.

solltest dir vllt nochmal die schleifen Grundlagen durchlesen: [Only registered and activated users can see links. Click Here To Register...] oder eurem Lehrer mal den Link geben :P
09/30/2011 19:00 Belur#22
Kaum das erste Problem gelöst, da ist das nächste da:

Wir haben eine Klasse, die beim erzeugen, eine Konsole ausgibt, mit einer bestimmten Anzahl, die man vorher eingegebenhat, an zufälligen Zahlen. Diese sind auch in der richtigen Reihenfolge geordnet.

Also kleinste Zahl -> größte Zahl

Soooo: Nun haben wir uns über den Aufwand unterhalten.
Wir sollten jetzt eine Methode machen, mit den Variablen von, bis und index, wobei der Aufwand möglichst klein sein soll. Dabei soll geprüft werden, ob eine eingegeben Zahl unter den zufällig erzeugten Zahlen vorhanden ist.

Wenn ich jeden Arrayeintrag prüfe wäre der Aufwand durchschnittlich ja n/2
Im besten Falle 1 und im schlechtesten Falle n.

Jetzt hab ich mir überlegt, ich hab die Variable von beim ersten Arrayeintrag, die Variable bis beim letzten. Jetzt prüfe ich mit der Indexvariable genau die hälfte.

Ist die Zahl größer als die gesuchte Zahl, setze ich das von an die Stelle von dem Index und das Index wieder bei der Hälfte zwischen von und bis.

Das dann immer so weiter etc. Ist die Zahl halt kleiner setze ich das bis an die Stelle vom Index etc.

Das ist jetzt ziemlich kompliziert. Der Aufwand ist dann nach meiner Überlegung der Logarithmus von n zur Basis 2. Ich denke das ist der geringste Aufwand. Zumindest wollte ich das so umsetzen.

Jetzt hab ich folgenden Quellcode geschrieben:

PHP Code:
public void zahlVorhanden(int zahlg){
        int von = 0;
        int bis = zahlenArray.length -1;
        int index = (von+bis)/2;

        while(zahlg != zahlenArray[index])
        {
            if(zahlenArray[index]< zahlg)
            {
                von = index;
                index = (von+bis)/2;
            }else{

                bis = index;
                index = (von+bis)/2;

            }
            if(zahlenArray[index] == zahlg)
            {
                System.out.println("Die Zahl ist vorhanden");

            }
            if(bis <= von){
                System.out.println("Die Zahl ist nicht vorhanden");
                break;
            }
        }
    } 

Ich lass mir also erst die Anzahl von Zahlen ausgeben. Will ich dann prüfen, ob eine Zahl vorhanden ist, von der ich weiß, dass sie es ist, klappt das auch.

Ist die Zahl allerdings nicht vorhanden, krieg ich eine Endlosschleife.
Ich kann mir denken, dass da irgendwo ein Fehler drin ist. ich vermute fast in der letzten If-Schleife aber beheben kann ich ihn nicht, trotz langem Rumprobieren.

Ich find das für mich selbst schon schwer im Kopf nachzuvollziehen, wie sich die Variablen verschieben und komm auch immer wieder durcheinander.


Ich hoffe hier hat einer das Problem verstanden.




Eine Lösung wäre, wenn ich das richtig vermute, den Logarithmus von der Länge des Arrays zu nehmen. Wird dann die Schleife öfter ausgeführt, als der Logarithmus groß ist, ist die Zahl nicht vorhanden.
Ob das so stimmt ist allerdings auch die Frage und ich denke, dass ist einfacher lösbar.


Vielen Dank für jede Hilfe.


Belur
09/30/2011 19:55 Obilee#23
Das beste Verfahren um in einem Array etwas zu Suchen ist die "Binärsuche". Dort haste im besten Fall O(1) und ansonsten immer O(log2n).

Wenn du Probleme hast mit den Sachen dann schreib dir einfach ein Beispiel Array auf ein Blatt und dann geh deine Schleife per Hand durch.

while(zahlg != zahlenArray[index])

Die Abfrage ist Problematisch, die while Prüft ja vor einem Durchlauf ob die Bedingung noch wahr ist. Wenn also von Anfang an zahlg der Zahl von zahlenArray[index] entspricht wird er nicht 1x einen Durchlauf machen.

Quote:
public final class BinäreSuche {

public static int suche(final char zeichen, final char[] alphabet) {
int erstes = 0;
int letztes = alphabet.length - 1;

while (erstes <= letztes) {
final int mitte = erstes + ((letztes - erstes) / 2); // vermeidet Überläufe des int
if (alphabet[mitte] < zeichen) {
erstes = mitte + 1; // rechts weitersuchen
} else if (alphabet[mitte] > zeichen) {
letztes = mitte - 1; // links weitersuchen
} else {
return mitte; // Zeichen gefunden
}
}

return -1;
}

}
Für dein Programm anpassen und gut ist.
Page 2 of 2 1 2