尾部递归-Java

我试图创建一个尾部递归的方法，并找到方程（

I/2i+1

）的

sum

，其中

I

需要递增

1-10

。我在如何到达基本情况并使递归停止方面遇到了困难

这就是我到目前为止所做的：

public class SumSeries {

    public static void main(String[] args) {
        System.out.println(sumSeries());
    }

    public static double sumSeries(){
        int i = 10;

        if (i == 0)
            return 0;
        else
            return (i / (2 * i + 1));
    }
}

---

我想你看起来是这样的：

public class SumSeries {

    public static void main(String[] args) {
        System.out.println(sumSeries(10,0));
    }

    public static double sumSeries(int i,double result){

        if (i == 1)
            return result;
        else{
          double res = result + (i / (double)(2 * i + 1));
          return sumSeries(i-1,res);
       }
   }
}

---

我想你看起来是这样的：

public class SumSeries {

    public static void main(String[] args) {
        System.out.println(sumSeries(10,0));
    }

    public static double sumSeries(int i,double result){

        if (i == 1)
            return result;
        else{
          double res = result + (i / (double)(2 * i + 1));
          return sumSeries(i-1,res);
       }
   }
}

---

我想你看起来是这样的：

public class SumSeries {

    public static void main(String[] args) {
        System.out.println(sumSeries(10,0));
    }

    public static double sumSeries(int i,double result){

        if (i == 1)
            return result;
        else{
          double res = result + (i / (double)(2 * i + 1));
          return sumSeries(i-1,res);
       }
   }
}

---

我想你看起来是这样的：

public class SumSeries {

    public static void main(String[] args) {
        System.out.println(sumSeries(10,0));
    }

    public static double sumSeries(int i,double result){

        if (i == 1)
            return result;
        else{
          double res = result + (i / (double)(2 * i + 1));
          return sumSeries(i-1,res);
       }
   }
}

---

如果您想要递归，您的方法应该如下所示：

public class SumSeries {

    public static void main(String[] args) {
        System.out.println(sumSeries());
    }

    // if you want to keep the argument-less method in main but want to calculate
    // the sum from 1 - 10 nevertheless.
    public static double sumSeries() {
      return sumSeries(10);
    }

    public static double sumSeries(int i){
        if (i == 0) {
            return 0;
        }
        else {
            // The cast to double is necessary. 
            // Else you will do an int-division here and get 0.0 as result.
            // Note the invocation of sumSeries here inside sumSeries.
            return ((double)i / (2 * i + 1)) + sumSeries(i-1);
        }
    }
}

---

如果您想要递归，您的方法应该如下所示：

public class SumSeries {

    public static void main(String[] args) {
        System.out.println(sumSeries());
    }

    // if you want to keep the argument-less method in main but want to calculate
    // the sum from 1 - 10 nevertheless.
    public static double sumSeries() {
      return sumSeries(10);
    }

    public static double sumSeries(int i){
        if (i == 0) {
            return 0;
        }
        else {
            // The cast to double is necessary. 
            // Else you will do an int-division here and get 0.0 as result.
            // Note the invocation of sumSeries here inside sumSeries.
            return ((double)i / (2 * i + 1)) + sumSeries(i-1);
        }
    }
}

---

如果您想要递归，您的方法应该如下所示：

public class SumSeries {

    public static void main(String[] args) {
        System.out.println(sumSeries());
    }

    // if you want to keep the argument-less method in main but want to calculate
    // the sum from 1 - 10 nevertheless.
    public static double sumSeries() {
      return sumSeries(10);
    }

    public static double sumSeries(int i){
        if (i == 0) {
            return 0;
        }
        else {
            // The cast to double is necessary. 
            // Else you will do an int-division here and get 0.0 as result.
            // Note the invocation of sumSeries here inside sumSeries.
            return ((double)i / (2 * i + 1)) + sumSeries(i-1);
        }
    }
}

---

如果您想要递归，您的方法应该如下所示：

public class SumSeries {

    public static void main(String[] args) {
        System.out.println(sumSeries());
    }

    // if you want to keep the argument-less method in main but want to calculate
    // the sum from 1 - 10 nevertheless.
    public static double sumSeries() {
      return sumSeries(10);
    }

    public static double sumSeries(int i){
        if (i == 0) {
            return 0;
        }
        else {
            // The cast to double is necessary. 
            // Else you will do an int-division here and get 0.0 as result.
            // Note the invocation of sumSeries here inside sumSeries.
            return ((double)i / (2 * i + 1)) + sumSeries(i-1);
        }
    }
}

---

如果您正在寻找一种方法来计算此金额：

(1 / 2*1 + 1) + (2 / 2*2 + 1) + (3 / 2*3 + 1) + ... + i/(2i + 1)

你可以试试这个：

public double sumSeries(int i) {
   if (i == 1) { // base case is 1 not 0
     return 1/3;
   } else {
     double s = i / (2.0 * i + 1.0);
     return s + sumSeries(i - 1);
   }
} 

---

如果您正在寻找一种方法来计算此金额：

(1 / 2*1 + 1) + (2 / 2*2 + 1) + (3 / 2*3 + 1) + ... + i/(2i + 1)

你可以试试这个：

public double sumSeries(int i) {
   if (i == 1) { // base case is 1 not 0
     return 1/3;
   } else {
     double s = i / (2.0 * i + 1.0);
     return s + sumSeries(i - 1);
   }
} 

---

如果您正在寻找一种方法来计算此金额：

(1 / 2*1 + 1) + (2 / 2*2 + 1) + (3 / 2*3 + 1) + ... + i/(2i + 1)

你可以试试这个：

public double sumSeries(int i) {
   if (i == 1) { // base case is 1 not 0
     return 1/3;
   } else {
     double s = i / (2.0 * i + 1.0);
     return s + sumSeries(i - 1);
   }
} 

---

如果您正在寻找一种方法来计算此金额：

(1 / 2*1 + 1) + (2 / 2*2 + 1) + (3 / 2*3 + 1) + ... + i/(2i + 1)

你可以试试这个：

public double sumSeries(int i) {
   if (i == 1) { // base case is 1 not 0
     return 1/3;
   } else {
     double s = i / (2.0 * i + 1.0);
     return s + sumSeries(i - 1);
   }
} 

---

您的方法不是递归的。递归方法需要使用“他自己”，并在特定条件下停止。例如：

public static double sumSeries(int x) { 
    if (x == 0)   
        return x;
    else {  
        return x + sumSeries(x - 1);
}

对于您的示例，类似这样的内容将适合：

public static double sumSeries(double x) {
    if (x == 0)   
        return x;
    else  
        return (x / (2 * x + 1)) + sumSeries(x - 1.0); 
}

---

如果我正确理解了您的算法：）如果没有，请编辑算法：）

您的方法不是递归的。递归方法需要使用“他自己”，并在特定条件下停止。例如：

public static double sumSeries(int x) { 
    if (x == 0)   
        return x;
    else {  
        return x + sumSeries(x - 1);
}

对于您的示例，类似这样的内容将适合：

public static double sumSeries(double x) {
    if (x == 0)   
        return x;
    else  
        return (x / (2 * x + 1)) + sumSeries(x - 1.0); 
}

---

如果我正确理解了您的算法：）如果没有，请编辑算法：）

您的方法不是递归的。递归方法需要使用“他自己”，并在特定条件下停止。例如：

public static double sumSeries(int x) { 
    if (x == 0)   
        return x;
    else {  
        return x + sumSeries(x - 1);
}

对于您的示例，类似这样的内容将适合：

public static double sumSeries(double x) {
    if (x == 0)   
        return x;
    else  
        return (x / (2 * x + 1)) + sumSeries(x - 1.0); 
}

---

如果我正确理解了您的算法：）如果没有，请编辑算法：）

您的方法不是递归的。递归方法需要使用“他自己”，并在特定条件下停止。例如：

public static double sumSeries(int x) { 
    if (x == 0)   
        return x;
    else {  
        return x + sumSeries(x - 1);
}

对于您的示例，类似这样的内容将适合：

public static double sumSeries(double x) {
    if (x == 0)   
        return x;
    else  
        return (x / (2 * x + 1)) + sumSeries(x - 1.0); 
}

---

---

如果我正确理解了您的算法：）如果没有，请编辑算法：）

好的，您的方法不包含递归。递归的意思是：从方法A中调用方法A。但你不是在方法体中调用sumSeries（）？！是不是你的else语句应该读作

return-sumSeries（i…

我不知道你在问什么。这个等式是不是类似于（1/2*1+1）+（2/2*2+1）+（3/2*3+1）+…？另外，正如其他人所指出的，递归意味着函数正在调用自身。您的代码不会这样做。@futureelite7是的，这就是方程应该如何工作。好吧，您的方法不包含递归。递归意味着：从方法a中调用方法a。但您没有调用sumSeries（）在你的方法主体中？！你的else语句是否应该像

return sumSeries（i…

我不知道你在问什么。这个等式是不是像（1/2*1+1）+（2/2*2+1）+（3/2*3+1）那样+…？另外，正如其他人所指出的，递归意味着函数正在调用自身。您的代码不会这样做。@futureelite7是的，这就是方程应该如何工作。好吧，您的方法不包含递归。递归意味着：从方法a中调用方法a。但您没有调用sumSeries（）在你的方法主体中？！你的else语句是否应该像

return sumSeries（i…

我不知道你在问什么。这个等式是不是像（1/2*1+1）+（2/2*2+1）+（3/2*3+1）那样+…？另外，正如其他人所指出的，递归意味着函数正在调用自身。您的代码不会这样做。@futureelite7是的，这就是方程应该如何工作。好吧，您的方法不包含递归。递归意味着：从方法a中调用方法a。但您没有调用sumSeries（）在你的方法主体中？！你的else语句是否应该像

return sumSeries（i…

我不知道你在问什么。这个等式是不是像（1/2*1+1）+（2/2*2+1）+（3/2*3+1）那样+…？另外，正如其他人所指出的，递归意味着函数正在调用自身。您的代码不会这样做。@futureelite7是的，这就是等式应该如何工作。现在检查我忘记了转换为双精度，对此表示歉意：）基本情况应该是

1

而不是

0

，OP说

i

从

1

增加到

10

现在检查我忘记了加倍，对此表示抱歉：）基本情况应该是

1

而不是

0

，OP说

i

从

1

增加到

10

现在检查我忘记了加倍，对此表示抱歉：）基本情况应该是

1

而不是

0

，OP说

i

从

1

增加到

10

检查现在我忘了加倍，很抱歉：）基本情况应该是

1

而不是

0

，OP说

i

从

1

增加到

10

这个答案很接近，但是当我在一个在线计算器上运行这个问题时，总数是6.066。。。但是这个代码的总和是4.40，因为sumSeries（i-1）是从总和中减去的。我如何保持代码，这样我就可以达到基本情况，但不使用公式求和？6.066的和是不正确的。看见在这个方法中我没有减去任何东西。我只是把10到1的所有元素相加。正好相反：）哦，谢谢。我使用了那个确切的站点，得到了6.066的总数。用户错误：）这个答案很接近，但当我在一个在线计算器中运行这个问题时，总和是6.066。。。但是这个代码的总和是4.40，因为sumSeries（i-1）是从总和中减去的。我如何保持代码，这样我就可以达到基本情况，但要将其从与等式求和中移除