Question

我很迷茫。我需要递归地找到数组中的第二个最小整数。我已经开始编写方法，但我知道它错了，不知道从哪里开始。

public static int findSecondSmallest(int [] array)
{
    int secSmall = array[0], min = array[0];
    if(array.length >= 1)
    {
        findSecondSmallest(array);
        if(secSmall > min)
            secSmall = array[0+1];
    }

    return secSmall;
}

Answer 1

当您从头到尾遍历数组时，您可以做的是跟踪最小的一个和第二个最小的一个。如果遇到小于第二小的东西或大于最小但小于第二小的东西，则更新它们。希望以下代码有意义：

public class Driver {
    public static int MAX_VAL = 1000000;
    public static void main(String[] args) {
        int[] arr = {2,5,3,6,2,7,43,2,56,2,-1, 1, 5};
        int[] smalls = new int[2];
        int sm = find(arr, 0, smalls);
        System.out.println(sm);
    }

    public static int find(int[] arr, int index, int [] smalls) {
        if(index == 0) {
            smalls[0] = arr[index];
            smalls[1] = Integer.MAX_VALUE;
            find(arr, index+1, smalls);
        } else if(index < arr.length){
            if(arr[index] < smalls[0]){
                smalls[1] = smalls[0];
                smalls[0] = arr[index];
            } else if(smalls[1] > arr[index]) {
                    smalls[1] = arr[index];
            }
            find(arr,index + 1, smalls);
        }
        return smalls[1];
    }
}

此处，index代表“部分数组”中最后一个元素的索引。每个递归步骤，您检查数组的第一个索引+ 1个元素。注意：small [0]是部分数组的SMALLEST元素，small [1]是部分数组的第二小元素。

对于递归的良好治疗，我建议你选择Prolog。这种语言没有循环，你将非常依赖递归。

Answer 2

这很容易迭代，所以递归解决方案已经有点做作了，有几种方法可以做到。例如，您可以编写一个函数，该函数在数组的两半上进行递归，并返回返回的四个数字中的第二个。我假设您想要拆分第一个元素并递归到数组的其余部分。

递归函数将返回IntPair中的最小和第二小函数，我省略了其定义，因此您需要一个包装函数来从该对中提取第二个最小值。

public static int findSecondSmallest(int[] array) {
    return findSecondSmallestAndSmallest(0, array).getSecond();
}

private static IntPair recurseSecondSmallest(int index, int[] array) {
    if (array.length - index == 2) {
        if (array[index] < array[index+1])
            return new IntPair(array[index], array[index+1]);
        else return new IntPair(array[index+1], array[index]);
    }
    IntPair recursiveResult = recurseSecondSmallest(index+1, array);
    if (array[index] < recursiveResult.getFirst())
        return new IntPair(array[index], recursiveResult.getFirst());
    else if (array[index] < recursiveResult.getSecond())
        return new IntPair(recursiveResult.getSecond(), array[index]);
    else return recursiveResult;
}

Answer 3

技巧是更智能的伪代码。这可能不是最有效的算法，但它的愚蠢聪明。在任何情况下，递归都不是解决这个问题的方法。

secondsmallest（大小为n的数组）

  if n == 2
     if array[0] < array[1]
         return array[1]
     else return array[2]

 if n not equal 2 then

    remove largest element from the array
    return secondsmallest(newArray of size n-1)

试图在递归java中找到数组中的第二个最小整数

3 个答案: