Java：递归查找列表中的最小元素

我先说这是家庭作业。我只是在找一些指针。我一直在绞尽脑汁想这件事，我这辈子都不明白。我们被要求在列表中找到最小元素。我知道我需要一个子列表在这里，但之后我不确定。任何指点都很好。谢谢

/** Find the minimum element in a list.
 * 
 * @param t a list of integers
 * 
 * @return the minimum element in the list
 */ 
  public static int min(List<Integer> t) { 
  if (t.size() == 1){ 
  return t.get(0); 
  } 
  else{ 
      List<Integer> u = t.subList(1, t.size());

/**查找列表中的最小元素。
* 
*@param t是一个整数列表
* 
*@返回列表中的最小元素
*/ 
公共静态int min（列表t）{
如果（t.size（）==1）{
返回t.get（0）；
} 
否则{
列表u=t.子列表（1，t.size（））；

递归算法的要点是，所有必须计算的内容都是通过返回值或附加参数来完成的。在递归步骤的本地调用之外，不应该有任何内容

由于必须找到最小元素，因此应考虑以下因素：

• 由一个元素组成的列表的最小元素就是该元素
• 一般列表的最小元素是第一个元素和剩余列表的最小元素之间的最小值

---

考虑到这些因素，应该很容易实现。特别是因为递归算法非常方便，与算法描述非常相似。

您需要找到应用于列表的函数min和应用于子列表的函数min之间的关系

最小值（[AB c d e…]）=f（a，最小值（[b c d e…]））

---

现在，您只需要找到函数f。一旦建立了关系，那么实现它就很容易了。祝您好运。

在最一般的意义上，递归是一个基于分解工作，然后将较小的工作部分委托给您自己的副本的概念。要使递归工作，您需要三个主要方面：

工作分解。你打算如何使每一步“更简单”

递归调用。在某些时候，函数必须调用自身，但“工作量”较少

基本情况。停止递归过程的（通常是琐碎的）结束情况是什么

---

在您的例子中，您正试图创建一个在列表上运行的函数

min

。您认为可以通过每次将列表缩小一个来减少（分解）工作量是正确的（将第一个元素列出来）。正如其他人所提到的，这样做的目的是检查第一个元素（您刚刚删除）与“列表的其余部分”相反。这就是信心的飞跃。此时，您可以“假设”您的

min

函数将在子列表上工作，只需在子列表上进行函数调用（递归调用）。现在您必须确保所有调用都将返回（即确保它不会永远递归）。这就是基本情况。如果列表的大小为1，则唯一的元素是列表中最小的元素。无需再次调用

min

，只需返回（您在原始帖子中已经包含的部分）。

好了，请尝试以下方法：

    public static Integer minimum(List<Integer> t) {
        int minInt;
       if (t.size() == 1) {
        return t.get(0);
       } else {
            int first = t.get(0);
            List<Integer> u = t.subList(1, t.size());
            minInt = Math.min(first, u.get(0));
            minInt = IntegerList.minimum(u);
          }
         return minInt;
      }

公共静态整数最小值（列表t）{
国际货币基金组织；
如果（t.size（）==1）{
返回t.get（0）；
}否则{
int first=t.get（0）；
列表u=t.子列表（1，t.size（））；
minInt=Math.min（首先，u.get（0））；
最小值=整数列表最小值（u）；
}
返回minInt；
}

希望这能解决您的问题。

/**
/**
 * The function computes the minimum item of m (-1 if m is empty). 
 * @param m: The MyList we want to compute its minimum item.
 * @return: The minimum item of MyList    
 */ 
public int minimum(MyList<Integer> m){

    int res = 0;
    int e0 = 0;
    int e1 = 0;

    // Scenarios Identification
    int scenario = 0;

    // Type 1. MyLyst is empty
    if(m.length() == 0) {
        scenario = 1;
    }else {
    // Type 2. MyLyst is not empty
        scenario = 2;
    }

    // Scenario Implementation
    switch(scenario) {

    // If MyLyst is empty
    case 1:
        res = -1;
        break;
        // If there is 1 or more elements   
    case 2:
        //1. Get and store first element of array
        e0 = m.getElement(0);
        //2. We remove the first element from MyList we just checked
        m.removeElement(0);
        //3. We recursively solve the smaller problem
        e1 = minimum(m); 
        //4. Compare and store results
        if(e0 < e1) {
            res = e0;
        }
        else {
            res = e1;
        }
        //5. Return removed element back to the array
        m.addElement(0, e0);
        break;
    }
    //6. Return result 
    return res;
}

*该函数计算m的最小项（-1，如果m为空）。
*@param m:MyList我们要计算它的最小项。
*@return:MyList的最小项
*/ 
公共整数最小值（MyList m）{
int res=0；
int e0=0；
int e1=0；
//情景识别
int场景=0；
//类型1。MyLyst为空
如果（m.length（）==0）{
情景=1；
}否则{
//类型2。MyLyst不是空的
情景=2；
}
//场景实现
切换（场景）{
//如果MyLyst是空的
案例1：
res=-1；
打破
//如果有1个或多个元素
案例2：
//1.获取并存储数组的第一个元素
e0=m.getElement（0）；
//2.我们从刚才检查的MyList中删除第一个元素
m、 移除元素（0）；
//3.我们递归地解决较小的问题
e1=最小值（m）；
//4.比较并存储结果
if（e0

请记住，您必须在某个点进行比较。这会很昂贵，为什么不说如果元素0小于元素1，则返回移除1的列表的最小值，否则返回移除0的列表的最小值基于前面两条注释的另一个提示…也许您应该有另一个基本情况，其中列表的大小为2。I在这种情况下，您将返回两个元素中较小的一个。否则您将把第一个元素与“列表的其余部分”中最小的元素进行比较。是的，我知道这是家庭作业，不得不说总是有

Math.min（）

。：-）“递归是一个基于分解工作的概念”->也称为“分而治之”策略。