java数组递归方法中的最小整数

我需要编写一个递归方法，通过数组查找最小的索引，但是我有一个奇怪的问题，出于某种原因，我给定的测试数组似乎返回10的结果。我曾尝试在eclipse中调试，但发生了一些非常奇怪的事情，我的findMinAux方法确实发现-10是最小的值，当我按下“step into”（步进）按钮时，它看起来好像要返回-10，但随后它进入了一些奇怪的循环，startIndex出于某种原因开始增加。如果有人对我的错误有任何建议，我们将不胜感激，谢谢

这是我的密码：

public class Q1 {

public static void main(String[] args) {

    int[] testArr = {12,32,45,435,-1,345,0,564,-10,234,25};
    findMin(testArr);

}

public static int findMin(int[] arr) {

    int result = findMinAux(arr,arr.length-1,arr.length-1);
    System.out.println(result);
    return result;

}

public static int findMinAux(int[] arr, int startIndex, int smallest) {

    if(arr[startIndex]<smallest) {

        smallest = arr[startIndex];

    }

    startIndex--;

    if(startIndex>=0) {

        findMinAux(arr,startIndex,smallest);

    }

    return smallest;

}

}

公共类Q1{
公共静态void main（字符串[]args）{
int[]testArr={12,32,45435，-1345,0564，-10234,25}；
findMin（testArr）；
}
公共静态int findMin（int[]arr）{
int result=findMinAux（arr，arr.length-1，arr.length-1）；
系统输出打印项次（结果）；
返回结果；
}
公共静态int findMinAux（int[]arr，int startIndex，int最小）{
如果（arr[startIndex]=0）{
findMinAux（arr，startIndex，最小）；
}
返回最小；
}
}

两个问题：

首先，如果要从数组末尾进行搜索，则应使用最后一个元素启动

最小的
：

 int result = findMinAux(arr,arr.length-1,arr[arr.length - 1]);

其次，您应该重新分配
最小的
：

if(startIndex>=0) {
    smallest = findMinAux(arr,startIndex,smallest);
}

请参阅此代码。在每次迭代中，将元素与当前元素进行比较，并在比较的基础上增加索引。这也是尾部递归。因此，它也可以用于大型阵列

public class Q1 {
    public static void main(String[] args) {

        int[] testArr = {12, 32, 45, 435, -1, 345, 0, 564, -10, 234, 25};
        System.out.println();
        System.out.println(find(testArr, 0, testArr.length - 1, testArr[0]));
    }

    public static int find(int[] arr, int currPos, int lastPos, int elem) {
        if (currPos == lastPos) {
            return elem;
        } else {
            if (elem < arr[currPos]) {
                return find(arr, currPos + 1, lastPos, elem);
            } else {
                return find(arr, currPos + 1, lastPos, arr[currPos]);
            }
        }
    }
}

公共类Q1{
公共静态void main（字符串[]args）{
int[]testArr={12,32,45435，-1345,0564，-10234,25}；
System.out.println（）；
System.out.println（find（testArr，0，testArr.length-1，testArr[0]）；
}
公共静态int find（int[]arr、int currPos、int lastPos、int elem）{
如果（currPos==lastPos）{
返回元素；
}否则{
如果（元素
实际上，此实现工作正常

 public static int findMinAux(int[] arr, int startIndex, int smallest) {
        if(startIndex < 0)
            return smallest;
        if(arr[startIndex] < smallest){
            smallest = arr[startIndex];
        }
        return findMinAux(arr, startIndex - 1, smallest);
}

改为

        int result = findMinAux(arr,arr.length-2, arr[arr.length - 1]);

这种方法使用单个方法和重载版本，因此不必传递初始值

    public static int findMin(int[] arr) {
    int index = 0;
    int min = Integer.MAX_VALUE;
      min = Math.min(arr[index], min);
      return findMin(arr,index+1,min);
    }


   private static int findMin(int[] arr, int index, int min) {
    if(index < arr.length)
    {
         min = Math.min(arr[index], min);
         return findMin(arr,index+1,min);
    }
    System.out.println(min);
    return min;
   }

公共静态int findMin（int[]arr）{
int指数=0；
int min=整数最大值；
最小值=数学最小值（arr[index]，min）；
返回findMin（arr，索引+1，min）；
}
私有静态int-findMin（int[]arr，int-index，int-min）{
if（索引

第二个方法是私有的，因此从类外部只能调用第一个/默认方法。
类最小值{
    class Minimum {
    int minelem;
    int minindex;
    Minimum() {
        minelem = Integer.MAX_VALUE;
        minindex = -1;
    }
}

public class Q1 {
public static void main(String[] args) {
    int[] testArr = {12,32,45,435,-1,345,0,564,-10,234,25};
    findMin(testArr);
}
public static int findMin(int[] arr) {
    Minimum m = new Minimum();
    m = findMinAux(arr,arr.length-1,m);
    System.out.println(m.minindex);
    return m.minindex;

}

public static Minimum findMinAux(int[] arr, int lastindex, Minimum m) {

    if(lastindex < 0) {
        return m;
    }

    if(m.minelem > arr[lastindex]) {
        m.minelem = arr[lastindex];
        m.minindex = lastindex;
    }

    return findMinAux(arr,lastindex - 1, m);

}
}

内特米勒姆；
int-minindex；
最小值（）{
minelem=整数的最大值；
minindex=-1；
}
}
公开课Q1{
公共静态void main（字符串[]args）{
int[]testArr={12,32,45435，-1345,0564，-10234,25}；
findMin（testArr）；
}
公共静态int findMin（int[]arr）{
最小值m=新的最小值（）；
m=findMinAux（arr，arr.length-1，m）；
System.out.println（m.minindex）；
返回m.minindex；
}
公共静态最小findMinAux（int[]arr，int lastindex，最小m）{
如果（lastindex<0）{
返回m；
}
如果（m.minelem>arr[lastindex]）{
m、 minelem=arr[lastindex]；
m、 minindex=最新指数；
}
返回findMinAux（arr，lastindex-1，m）；
}
}

为了简化，我在这里使用了另一个类。请检查这是否解决了您的问题，同时我正在解释为什么以及它是如何工作的。
提示：我不允许循环，这是一项大学作业，我必须使用递归，如我的帖子中所述：）@cannedMoose findMinAux的第三个参数（arr，arr.length-1，arr.length-1）是错误的啊，是的，它总是一个愚蠢的错误，不是吗？这解决了它，谢谢。它返回最小的元素。也许它不会改变它的签名。使用递归的意义不仅仅是调用一个函数。代码应该简洁易读为什么需要这样？我已经使用了user6690200解决方案，我的代码现在可以工作了对不起，我只是想说，通过这种方式，它工作得很好。无论如何，递归的一般规则是：1。基本情况。您必须始终具有一些基本情况，这些基本情况无需递归即可解决。2.递归。对于要递归解决的情况，递归调用必须始终是向基本情况前进的情况。为了避免意外错误，最好检查
1
，然后检查
2
是，但使用额外的辅助方法意味着您可以提供一种只需要一个参数的方法，我们鼓励您这样做，以便更好地实践。我已经修改了答案，因为您喜欢这样做。只是另一种选择。
    class Minimum {
    int minelem;
    int minindex;
    Minimum() {
        minelem = Integer.MAX_VALUE;
        minindex = -1;
    }
}

public class Q1 {
public static void main(String[] args) {
    int[] testArr = {12,32,45,435,-1,345,0,564,-10,234,25};
    findMin(testArr);
}
public static int findMin(int[] arr) {
    Minimum m = new Minimum();
    m = findMinAux(arr,arr.length-1,m);
    System.out.println(m.minindex);
    return m.minindex;

}

public static Minimum findMinAux(int[] arr, int lastindex, Minimum m) {

    if(lastindex < 0) {
        return m;
    }

    if(m.minelem > arr[lastindex]) {
        m.minelem = arr[lastindex];
        m.minindex = lastindex;
    }

    return findMinAux(arr,lastindex - 1, m);

}
}