Suche ein 2D-Array

Habe ich instanziiert ein 2D-array mit einer bearbeitbaren Anzahl von Zeilen und eine bestimmte Anzahl von drei Spalten.

Ist es zufällig gefüllt mit 0 und 1 ist mithilfe von Random .nextInt(2) - Methode.

Nachdem das array gefüllt ist, ich möchte in der Lage zum durchsuchen des array und Rückgabe der ersten Entstehung von 0.

Wie kann ich dies tun?

Zum Beispiel, wenn ich ein array, das so ähnlich aussah:

  • 1 1 0
  • 0 1 0
  • 1 1 1

Das erste auftauchen würde (0,3). Ich möchte suchen das array horizontal und, wenn es erreicht die Dritte Spalte (das Ende), geht es in die nächste Zeile.

Hinweis: ich ursprünglich getestet der folgende code-Abschnitt, der mit einem 2D-array, das war komplett gefüllt mit 0 und wenn ich manuell eingefügt 1 im array und dann versucht, auf der Suche nach dem ersten vorkommen einer 0 es funktionierte. Aber der code funktioniert nicht, wenn das array wird zufällig gefüllt..

 public String findNextAvailable()
{ 
    for (int i=0; i<seatlist.length; i++) 
    { 
        for (int j=0; j<seatlist[i].length; j++)
        {

            int k=0;
            if (seatlist[0][0]==0) 
            { 
                nextavailable= seatchart[0][0];
                break;
            }
            else
            if(seatlist[k][j]==0)
            {
                nextavailable= seatchart[k][j];
                break;
            }
            else 
            {   k++;
                if(seatlist[k][j]==0) 
                {
                    nextavailable= seatchart[k][j];
                    break;
                }    
            }

        }
    }
    return nextavailable;
}

Vielen Dank im Voraus!

Möchtest du wieder die Positionen?
Für bessere Hilfe früher, nach einem SSCCE.
Wie verstehen Sie das erste vorkommen in einem 2D-array?
Ich will auf Rückgabe der position des ersten Vorkommens.
Sorry! Ich bearbeitet meine post, um das erste auftauchen klarer!

InformationsquelleAutor nichi | 2013-05-23

  1. 3
    for (int i = 0; i < seats.length; i++) {
        for (int j = 0; j < seats[i].length; j++) {
            if (seats[i][j] == 0) {
                return "Next available seat at position: [" + i + "][" + j + "]";
            }
        }
 }
 return "No seat available";

    Obwohl möglicherweise möchten Sie erstellen eine Sitz-Objekt, das anstelle, dass ist einfacher, mit zu arbeiten:

    public class Seat {

    private int row;
    private int column;

    public Seat(int row, int column){
        this.row = row;
        this.column = column;
    }
    public int getRow() {
        return row;
    }

    public int getColumn() {
        return column;
    }
}

    und ersetzen Sie die Rückgabe eines Strings mit:

    return new Seat(i,j);
    Ja, in meinen Sitzplan Klasse, ich habe eigentlich 2 verschiedene 2D-Arrays, eine, die numerische und speichert die 1 und die 0 ist oben gezeigt wird, und eine, die speichert die Sitz-Nummern, wie 1A, 1B, 1C, 2A... Mein original-code gibt die Platznummer der zweite array Suche das erste array eine 0 und dann wieder den entsprechenden Platz in der zweiten Reihe.
    Ich denke, Sie verlängern könnte, was ich hatte, weiter in der Seat-Klasse an eine sinnvolle position wie 1A etc. Sie kann auch ein Ort Klasse aus einer Liste<Zeile> und eine Zeile ist eine Liste<Sitz - > und alles könnte so eingestellt sein, wenn Sie Ihre Venue-Objekt.
    Der Sitz Klasse sollte wirklich nur eine zusätzliche Methode, die bietet eine Sitz-Zahl, die ein Mensch verstehen kann wie 1A etc. nach seinen eigenen Zeile / Spalte die Werte und transformieren der Spalten Buchstaben.
    Danke! Habe es endlich an die Arbeit!

    InformationsquelleAutor John484

  2. 1

    gut, wenn Sie break in der inneren Schleife, die Sie noch ausführen wieder die äußere Schleife, und Sie wind-up ersetzen, was Sie denken, ist Ihre Letzte Ergebnis mit dem nächsten Durchlauf der äußeren Schleife. statt zu brechen, nur Rückgabe Recht gibt.

    InformationsquelleAutor LanternMike

  3. 1

    Müssen Sie zurück die Positionen der ersten Begegnung mit 0, also, warum sind Sie brechen aus der if-Anweisung der äußeren Schleife wird noch ausgeführt!

    Erstellen Sie einfach ein integer-array: 

    int[] pos=new array[2];

    Ändern Sie den Rückgabetyp:

    public int[] findNextAvailable(){

    In jedem der if-Anweisungen den Inhalt zu ändern, so dass es liest:

    pos[0]=i;
pos[1]=j;
return pos;

    Das Endergebnis wird in etwa so Aussehen:

        public int[] findNextAvailable()
{ 
    int[] pos=new array[2];
    for (int i=0; i<seatlist.length; i++) 
    { 
        for (int j=0; j<seatlist[i].length; j++)
        {

            if (seatlist[i][j]==0) 
            { 
                pos[0]=i;
                pos[1]=j;
                return pos;
            }


        }
    }

   //none found so return minus one.
    pos[0]=-1;
    pos[1]=-1;

    return pos;
}
    Sorry! Ich habe es zu arbeiten 🙂 ich Danke Ihnen sehr für Ihre Hilfe!

    InformationsquelleAutor James

  4. 0

    es gibt viele verschiedene Arten von sucht, manche schneller und manche leichter zu tun. Hier ist ein Programm, das ich gemacht, hat Methoden für alle Arten von Ihnen. Sie haben Sie zu ändern ein wenig, so wird es such ein 2d-array, aber es sollte nicht zu hart sein.
    '
    Paket linear_search;
    import java.util.Arrays;
    import java.util.Scanner;

    public class Linear_search {
int[] array = {10,12,42,7,22,1,3,4,5,9};
int ans;
int num;
int min;
int max;
void start(){
    arraySort(array);
    dump(array);
    Scanner scan = new Scanner(System.in);
    System.out.println("Enter a value to search:");
    num = scan.nextInt();
    ans = recursiveBinarySearch(array, 0, array.length-1);
    if(ans == -1){
        System.out.println("Your value was not found");
    } else {
    System.out.println("Your value was found at position " + ans);
    }
    }
    void dump(int[] array){
     for(int i = 0; i < array.length ; i++){
         System.out.print(array[i] + " ");
     }
     System.out.println();
     }
     int linearsearch(int[] array){
     for(int i = 0; i < array.length; i++){
         if(array[i] == num){
         return i;
     }
     }
     return -1;
     }
     int binarysearch(int[] array){
     min = 0;
     max = array.length -1;
     int mid = (min + max) / 2;

     while(array[mid] != num){
     if(num > array[mid]){
         min = mid+1;
         mid = (min + max) / 2;
     }
     if(num < array[mid]){
         max = mid-1;
         mid = (min + mid) / 2;
     }
     if(min == max && array[mid] != num){
         return -1;
     }
     }
     return mid;
     }
     int recursiveBinarySearch(int[] array, int min, int max){
     int mid = (min + max) / 2;
     if(array[mid] == num){
         return mid;
     } 
     if(min == max && array[mid] != num){
         return -1;
     }
     if(num > array[mid]){
         return recursiveBinarySearch(array, mid+1, max);
     }
     if(num < array[mid]){
         return recursiveBinarySearch(array, min, mid-1);
     }
     return mid;
     }
     void arraySort(int[] a){
    Arrays.sort(array);
    }
     public static void main(String[] args) {
     Linear_search main = new Linear_search();
     main.start();
    } 
}

    '
    Sie haben nur entfernen Sie die scanner-und hard-code "0" als Standardwert sollten Sie Suche für.

    InformationsquelleAutor Nolan Gormley

Schreibe einen Kommentar