搜索二维数组

Question

我已经实例化了一个包含可编辑行数和一组三列数的二维数组。

使用 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

有许多不同类型的搜索，有些更快，有些更容易完成。这是我制作的一个程序，其中包含所有类型的方法。您将不得不对它们进行一些修改，以便搜索二维数组，但应该不会太难。 ' 包线性搜索； 导入 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”中的扫描仪和硬代码即可获得您应该搜索的默认值。