搜索二維數組

Question

我實例化了一個2D數組，該數組具有可編輯數量的行和固定數量的三列。

使用Random .nextInt（2）方法將其隨機填充為0和1。

數組填充后，我希望能夠搜索數組並返回第一次出現的0。

我怎樣才能做到這一點？

例如，如果我有一個看起來像這樣的數組：

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

第一次出現在（0,3）。 我想水平搜索數組，當它到達第三列（末尾）時，它將轉到下一行。

注意：最初，我用完全充滿0的2D數組測試了以下代碼部分，當我在數組中手動​​插入1並嘗試搜索首次出現的0時，它起作用了。 但是，當隨機填充數組時，代碼不起作用。

 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;
}

提前致謝！

Answer 1

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";

盡管您可能想創建一個座位對象，但是使用起來更容易：

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;
    }
}

並將返回的字符串替換為：

return new Seat(i,j);

Answer 2

好的，當您在內部循環中中斷時，仍然可以再次執行外部循環，然后最終將您認為是最終結果的內容替換為下一輪外部循環。 而不是使用break，只需返回就可以了。

Answer 3

您需要返回遇到的第一個0的位置，因此為什么要中斷if語句，外部循環仍將運行！

只需創建一個整數數組：

int[] pos=new array[2];

更改返回類型：

public int[] findNextAvailable(){

在每個if語句中更改內容，使其內容如下：

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

最終結果將如下所示：

    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;
}

Answer 4

搜索的類型很多，有些更快，有些更容易實現。 這是我制作的程序，其中包含針對所有類型的方法。 您將需要對其進行一些修改，以便它可以搜索2d數組，但應該不會太難。 'package linear_search; 導入java.util.Arrays; 導入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();
    } 
}

'您只需要刪除掃描儀和“ 0”中的硬編碼，即可獲取應搜索的默認值。