在Java中递归查找向量中的最大值

所以对于一个编程类，我们需要递归地找到向量的最大值和最小值。我知道如何使用迭代来实现这一点，但我不知道我需要做些什么来实现这个任务所需的递归。如果我能得到索引的话，我就可以通过使用元素at得到最大值和最小值，但是我迄今为止所做的一切都让我产生了大量的错误。这是我到目前为止所有的代码

import java.util.*;
import java.io.*;

public class Lab4<E> {
    Vector <Double> data; 
    public void readData() throws FileNotFoundException
    {
        {
            Scanner console = new Scanner (System.in);
            System.out.println("Enter the data file name: ");
            String inFile = console.next();
            File fileRef = new File(inFile);
            Scanner tokens = new Scanner(fileRef);
            data = new Vector<Double>();
            while(tokens.hasNext())
                {
                Double value = tokens.nextDouble();
                data.add(value);
                }
            System.out.print("The values in the file are: "+data.toString()+"\n");
            System.out.print("The number of values in the file is: "+(data.size())+"\n");
            tokens.close();
            console.close();
        }
    }   
    public static void main(String[] args) 
            throws IOException
    {
    Lab4 fileTest = new Lab4();
    fileTest.readData();
    System.out.println(obj);
    }

    class MinMaxObject
    {
        private double max, min;
        private int maxPos, minPos;
         public MinMaxObject()
          {
            this.max =Double.MIN_VALUE;
            this.maxPos = 0;
            this.min=Double.MAX_VALUE;
            this.minPos = 0;

         }
         public MinMaxObject(double ma, int maP, double mi, int miP)
         {
            this.max = ma;
            this.maxPos = maP;
            this.min = mi;
            this.minPos = miP;
         }
        public void setMax(double newMax)
        {
            max = newMax;
        }
        public double getMax() {
            return max;
            } 
        public void setMin(double newMin)
        {
            min = newMin;
        }
        public double getMin() {
            return min;
            } 
        public void setMaxPos(int newMaxPos)
        {
            maxPos = newMaxPos;
        }
        public int getMaxPos() {
            return maxPos;
            } 
        public void setMinPos(int newMinPos)
        {
            minPos = newMinPos;
        }
        public int getMinPos() {
            return minPos;
            } 
    }
}

import java.util.*；
导入java.io.*；
公共类Lab4{
矢量数据；
public void readData（）引发FileNotFoundException
{
{
扫描仪控制台=新扫描仪（System.in）；
System.out.println（“输入数据文件名：”）；
字符串infle=console.next（）；
文件fileRef=新文件（infle）；
扫描器令牌=新扫描器（fileRef）；
数据=新向量（）；
while（tokens.hasNext（））
{
Double value=tokens.nextDouble（）；
数据增值；
}
System.out.print（“文件中的值为：“+data.toString（）+”\n”）；
System.out.print（“文件中的值数为：”+（data.size（））+“\n”）；
tokens.close（）；
console.close（）；
}
}   
公共静态void main（字符串[]args）
抛出IOException
{
Lab4 fileTest=新的Lab4（）；
fileTest.readData（）；
系统输出打印项次（obj）；
}
类MinMaxObject
{
私人双最大值，最小值；
专用int maxPos、minPos；
公共MinMaxObject（）
{
this.max=Double.MIN_值；
这是maxPos=0；
此.min=Double.MAX_值；
this.minPos=0；
}
公共MinMaxObject（双ma、整数映射、双mi、整数miP）
{
这个最大值=毫安；
this.maxPos=maP；
this.min=mi；
this.minPos=miP；
}
公共void setMax（双倍newMax）
{
max=newMax；
}
公共双getMax（）{
返回最大值；
} 
公共无效设置最小值（双新最小值）
{
min=newMin；
}
公共双getMin（）{
返回最小值；
} 
公共void setMaxPos（int newMaxPos）
{
maxPos=newMaxPos；
}
public int getMaxPos（）{
返回maxPos；
} 
公共void setMinPos（int newMinPos）
{
minPos=newMinPos；
}
public int getMinPos（）{
返回minPos；
} 
}
}

您可以使用如下代码递归获取向量的最小值：

static double min(Vector<Double> v, int index) {
    if (index == v.size() - 1) {
        return v.get(index);
    }
    double val = min(v, index + 1);

    if (v.get(index) < val) {
        return v.get(index);
    } else {
        return val;
    }
}

静态双最小值（向量v，整数索引）{
如果（索引==v.size（）-1）{
返回v.get（索引）；
}
双val=最小值（v，指数+1）；
如果（v.get（index）

---

您可以用同样的方法递归地找到最大值，只需在最后一个if语句中切换

即可递归地获得向量的最小值，代码如下：

static double min(Vector<Double> v, int index) {
    if (index == v.size() - 1) {
        return v.get(index);
    }
    double val = min(v, index + 1);

    if (v.get(index) < val) {
        return v.get(index);
    } else {
        return val;
    }
}

静态双最小值（向量v，整数索引）{
如果（索引==v.size（）-1）{
返回v.get（索引）；
}
双val=最小值（v，指数+1）；
如果（v.get（index）

---

你可以用同样的方法递归地找到最大值，只要在最后一个if语句中切换

，除非有使用

向量的特殊要求，否则不要，如果是，告诉老师将作业更新到比1998年更新的内容。1998年由Java 1.2中的back取代，javadoc说：

与新的集合实现不同，Vector是同步的。如果不需要线程安全实现，建议使用
ArrayList
代替
Vector

如果需要同步，我建议使用
ArrayList
而不是
Vector
，这意味着永远不应该使用
Vector
，除非与需要它的旧API一起使用


Java不支持尾部递归，但让我解释一下，因为这是其他支持尾部递归的语言的首选方式

当使用递归时，函数调用在调用堆栈上进行。最终，使用非常深的递归，您可能会耗尽堆栈空间，这将导致
StackOverflowException
并杀死您的程序

在纯函数式编程中，所有变量都是不可变的，在不使用堆栈空间的情况下执行循环的方法是使递归调用成为方法中的最后一件事。这样，函数编译器就可以简单地跳回方法的开头，而无需添加到调用堆栈中，这是因为在当前调用中没有更多的事情要做

为了使它适用于必须返回列表最大值的方法，递归调用将传递
列表
、下一个要处理的索引和迄今为止找到的最大值。在列表的末尾，它返回传入值

为了便于使用，通常有一个引入方法，所以调用方不必设置额外的参数

public static Integer max(List<Integer> list) {
    if (list.isEmpty())
        return null;
    return max(list, 1, list.get(0));
}
private static final Integer max(List<Integer> list, int index, Integer maxSoFar) {
    if (index == list.size())
        return maxSoFar;
    Integer value = list.get(index);
    Integer maxValue = (value.compareTo(maxSoFar) > 0 ? value : maxSoFar);
    return max(list, index + 1, maxValue); // tail-recursive call
}


要同时获得最小值和最大值，需要一个类来返回这两个值

代码也可以更新，以处理任何可比较的

public static final class MinMax<T> {
    private final T min;
    private final T max;
    MinMax(T min, T max) {
        this.min = min;
        this.max = max;
    }
    public T getMin() {
        return this.min;
    }
    public T getMax() {
        return this.max;
    }
}
public static <T extends Comparable<T>> Optional<MinMax<T>> minMax(Iterable<T> coll) {
    Iterator<T> iter = coll.iterator();
    if (! iter.hasNext())
        return Optional.empty();
    T value = iter.next();
    return Optional.of(minMax(iter, value, value));
}
private static final <T extends Comparable<T>> MinMax<T> minMax(Iterator<T> iter, T minSoFar, T maxSoFar) {
    if (! iter.hasNext())
        return new MinMax<>(minSoFar, maxSoFar);
    T value = iter.next();
    return minMax(iter, (value.compareTo(minSoFar) < 0 ? value : minSoFar),
                        (value.compareTo(maxSoFar) > 0 ? value : maxSoFar));
}

公共静态最终类最小值{
私人决赛T分钟；
私人最终T最大值；
最小最大值（T最小值，T最大值）{
this.min=min；
this.max=max；
}
公共T getMin（）{
返回这个.min；
}
公共T getMax（）{
返回此.max；
}
}
公共静态可选最小最大值（Iterable coll）{
迭代器iter=coll.Iterator（）；
如果（！iter.hasNext（））
返回可选的.empty（）；
T
public MinMaxObject getMinMax(Vector<Double> vector) {
    MinMaxObject minMax = new MinMaxObject();
    getMinMaxAux(vector, minMax, 0);
    return minMax;
}

public void getMinMaxAux(Vector<Double> vector, MinMaxObject minMax, int index) {
    if(index < vector.size())
    {
        double value = vector.get(index);
        if(value > minMax.getMax())
        {
            minMax.setMax(value);
            minMax.setMaxPos(index);
        }
        if(value < minMax.getMin())
        {
            minMax.setMin(value);
            minMax.setMinPos(index);
        }
        getMinMaxAux(vector, minMax, index + 1);
    }
}

Vector<Double> v = new Vector<Double>();
v.add(new Double("3.0"));
v.add(new Double("4.0"));
Object obj = Collections.max(v);
System.out.println(obj);