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

当你在内循环中打破时，你仍然会再次执行外循环，你最终会在下一轮外循环中取代你认为的最终结果。而不是使用休息，只需返回那里。

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

” 您只需要删除扫描仪和“0”中的硬编码作为您应搜索的默认值。

搜索2D阵列

4 个答案: