Question

我需要编写一个递归函数，该函数返回ArrayList中的最大和最小元素以及相应的索引。要返回这四个项目，我需要返回一个对象，该对象是名为MinMaxObject的内部类的实例，该实例具有四个已定义的私有变量：max，min，maxPos，double，double，int和int类型的minPos。

我已经一个人到这里了，我需要开始递归，但是我不知道该怎么做。如果有人可以将我指向正确的方向，那么我应该可以接住它。

public static void main(String args[]) {

    Scanner console = new Scanner(System.in);
    System.out.print("Please enter a file name");
    String fileName = console.next();

    try {
        File fileRef = new File(fileName);
        Scanner tokens = new Scanner(fileRef);
        double input = tokens.nextDouble();

        ArrayList<Double> list = new ArrayList<Double>();

        while (tokens.hasNextLine()) {
            list.add(input);
        }

        System.out.println("For Loop");
        for (int counter = 0; counter < list.size(); counter++) {
            System.out.println(list.get(counter));
        }

    } catch (FileNotFoundException e) {
        e.printStackTrace();
    }


// 2 functions, one initialize & one to call the original recursion
    //can start at beggining and recurse to the end or vice versa
    //updates the min and max as it goes
    //update minPos and maxPos as well
}

public class MinMaxObject {
    private double min;
    private double max;
    private int minPos;
    private int maxPos;

public MinMaxObject(double newMin, double newMax, int newMinPos, int newMaxPos){
    min = newMin;
    max = newMax;
    minPos = newMinPos;
    maxPos = newMaxPos;
}

public double getMin(){
    return min;
}

public void setMin(double newMin){
    min = newMin;
}

public double getMax(){
    return max;
}

public void setMax(double newMax){
    max = newMax;
}

public int getMinPos(){
    return minPos;
}

public void setMinPos(int newMinPos){
    minPos = newMinPos;
}
public int getMaxPos(){
    return maxPos;
}

public void setMaxPos(int newMaxPos){
    maxPos = newMaxPos;
}

Answer 1

听起来递归是分配的一部分。

最简单的方法是遍历arraylist，但是由于您需要递归，所以要复杂一些。由于这是家庭作业，并且因为我很懒，所以我不会为您提供可编译的Java代码。这是一个近似值。我也不会给您全部方法，因为您应该从这里弄清楚其余的方法。

private int min = 0;
private int max = 0;
findMinMax(int index, List<int> list)
{
    //in recursion always start your method with a base-case
    if(index >= list.Count)
        return ;

    //find min and max here

    //this is called tail recursion, it's basically the same as a loop
    findMinMax(index + 1, list);
}

Answer 2

感谢@ScubaSteve！ ...我概述了更多/细节：

void findMinMax(int idx, List items, MinMaxObject result) {
    // this is good:
    if (idx >= items.size()) {
        return;
    }
    // check whether list[idx] is min or max: compare with & store to 'result'

    // recursion:
    findMinMax(idx + 1, items, result);
}

初始/最终/外部调用为：

// initialize with high min, low max and "out of range" indices
// ...alternatively in default constructor/field declaration.
MinMaxObject result = new MinMaxObject(Integer.MAX_VALUE, Integer.MIN_VALUE, -1, -1);
// start recursion at index 0:
findMinMax(0, items, result);

递归替代方法是：不仅求助列表（idx : 0 ... size - 1）的“头”，而且求助于“ tail”，例如：

void findMinMax(int head, int tail, List items, MinMaxObject result) {
    if(head > tail) {
        // done!
        return;
    }
    // check items[head] and items[tail]... store to result
    // iterate:
    return findMinMax(head + 1, tail - 1, items, result);
}

“替代”将递归的次数减半（但使“内联复杂度”加倍）。

另一种“分而治之”的方法：

void findMinMax(int left, int right, items, result) {
    if(left > right) {
        return;// alternatively do nothing
    } else if (left == right) {
       //check items[left] ...
       // return;
    } else { // left < right
        int mid = (right - left) / 2;
        findMinMax(left, mid, items, result);
        findMinMax(mid + 1, right, items, result);
        // return;
    }
}

...具有（相同）O(n)复杂度。

Answer 3

类似这样的东西：

MinMaxObject findMaxMin(final ArrayList<Double> nums, MinMaxObject minMax, int pos){

        //Base Case
        if(pos >= nums.size()){
            return minMax;
        }

        //Check to see if the current element is bigger than max or smaller than min
        Double value = nums.get(pos); 
        if(value > minMax.getMax()){
            //adjust minMax

        }
        if(value < minMax.getMin()){
            //adjust minMax
        }

        //recursion
        return findMaxMin(nums, minMax, pos+1);


    }

只需确保使用适当的值初始化MinMaxObject（可能应将它们作为默认构造函数的一部分），例如： MinMaxObject minMax = new MinMaxObject(Integer.MAX_VALUE, Integer.MIN_VALUE, -1, -1);

希望我的参数顺序正确。

搜索“递归”和“累加器”这两个词可能会为您提供一些启发。

Answer 4

不需要递归。使用ArrayList List，这是一个示例。

Collections.sort(List)
return List.get(0); // Least number
return List.get(List.size()-1); // Max number

Answer 5

public void getMinMax(MinMaxObject minMaxObject, List list, int currentIndex)
{

if(list.get(currentIndex) < minMaxObject.getMin())

    minMaxObject.setMin(list.get(currentIndex) );
    minMaxObject.setMinPos(currentIndex) ;

else if(list.get(currentIndex) > minMaxObject.getMax())

    minMaxObject.setMax(list.get(currentIndex));
    minMaxObject.setMaxPos(currentIndex) ;

if(currentIndex < list.size-1) getMinMax(minMaxObject, list, ++currentIndex)

}

使用递归返回最小值和最大值及其在arraylist中的位置

5 个答案: