Java 数组中最小值的索引&引用；递归的；

我试图根据2d数组中的第一列查找最小值的第一个索引，这是我的函数：

int min = sortMyArray.findMinRecursive(array, n, 0);
System.out.println("Min = " + min);

n是行数，k开头是0

public int findMinRecursive(int[][] array, int n, int k) {
    int min;
    if (n == 1) {
        return array[0][k];

    } else {
        min = findMinRecursive(array, n - 1, k);
        if(min == array[n - 1][k]){
            k++;
        }
        if (min < array[n - 1][k]) {
            return min;
        }
        else {
            return array[n - 1][k];
        }
    }
}

查找二维数组中最小值的第一个索引

（对我而言）：在包含最小元素的整数数组中

a[minI][minJ]

return

minI

现在递归可以应用于两个级别（在二维数组中），我建议递归“行”（比较每行的最小值…并存储“行”的索引）：

更新：现在使用真正的递归，只比较第一列：

公共类Q50456760{
私有静态final int[]TEST_A={{0,1,2}，{3,4,5}，{6,7，-1}；
公共静态void main（字符串…参数）{
//系统输出打印LN（测试A）；
系统输出打印（“最小行索引（应为0）：”；
System.out.println（Q50456760.findMinRowIndexIter（TEST_A，Integer.MAX_值））；
系统输出打印（“递归：”）；
System.out.println（Q50456760.findMinRowIndexRec（TEST_A，0，Integer.MAX_VALUE，-1））；
}
私有静态int-findMinRowIndexIter（int[]arr，int-min）{
int minI=-1；
对于（int i=0；i

二维数组中的最小值有两个索引。您似乎正在查找

k

th列的最小值。只有您在本地修改

k

。你怎么称呼这个？我编辑了我的问题，这样问题就清楚了。在目前的状态下，这个问题很难理解。请编辑您的问题，包括示例输入和输出内容。请参阅：。您的更新没有考虑OP更新后的问题陈述：“根据2d数组中的第一列查找最小值的第一个索引。”啊，这甚至让它更容易：

findMinRec

只需要在第一（0）个元素上调用……那么，对于给定的

TEST\u a

（！？）)更新了关于第一列的内容（并修复了一个bug-还需要存储min！）

public class Q50456760 {

    private static final int[][] TEST_A = {{0, 1, 2}, {3, 4, 5}, {6, 7, -1}};

    public static void main(String... args) {
        //        System.out.println(TEST_A);
        System.out.print("Min row index (expected 0): ");
        System.out.println(Q50456760.findMinRowIndexIter(TEST_A, Integer.MAX_VALUE));
        System.out.print("Recursive: ");
        System.out.println(Q50456760.findMinRowIndexRec(TEST_A, 0, Integer.MAX_VALUE, -1));
    }

    private static int findMinRowIndexIter(int[][] arr, int min) {
        int minI = -1;
        for (int i = 0; i < arr.length; i++) {
            int currMin = findMinIter(arr[i], min);
            if (currMin < min) {
                min = currMin;
                minI = i;
            }
        }
        return minI;
    }

    private static int findMinRowIndexRec(int[][] arr, int i, int min, int minI) {
        int currMin = findMinRec(arr[i], 0, min);
        if (currMin < min) {
            min = currMin;
            minI = i;
        }
        i++;
        if (i < arr.length) {
            return findMinRowIndexRec(arr, i, min, minI);
        } else {
            return minI;
        }
    }

    private static int findMinIter(int[] arr, int min) {
        int result = min;
//            for (int aj : arr) {
        if (arr[0] < min) {
            result = arr[0];
        }
//            }
        return result;
    }

    private static int findMinRec(int[] a, int j, int min) {
        if (a[j] < min) {
            min = a[j];
        }
//            j++;
//            if (j < a.length) {
//                return findMinRec(a, j, min);
//            } else {
        return min;
//            }
    }
}