Question

Hello其他程序员。

我有一个非常愚蠢的问题..我应该递归地将List中的所有整数相加。我知道有一种更简单的方法可以做到这一点，我实际上也制作了这种方法（参见下面的课程）。但是这个赋值的意思是我必须将列表分成两半，然后在两半上递归计算总和，最后我只返回half1 + half2。

问题是高级方法不返回所有值的总和。有人可以帮帮我吗？

方法sum是简单的方法。夏天（总结为丹麦语）是更先进的方法。

package opgave1;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

public class BinærSøgning {
    public static void main(String[] args) {
        Random random = new Random();
        int tal = 3;

        List<Integer> liste = new ArrayList<Integer>();
        for (int i = 0; i < 10; i++)
            liste.add(random.nextInt(10));
        Collections.sort(liste);

        System.out.println(liste);
        //      System.out.println(binærSøgning(liste, 0, tal));
        System.out.println(summer(liste, 0));
    }

    public static int binærSøgning(List<Integer> liste, int start, int find) {
        if (liste.size() > 0) {
            int midt = liste.size() / 2;
            if (liste.get(midt) == find)
                return start + midt;
            else if (liste.size() > 1) {
                if (find < liste.get(midt))
                    return binærSøgning(liste.subList(0, midt), start, find);
                else
                    return binærSøgning(liste.subList(midt + 1, liste.size()), start + midt + 1, find);
            }
        }
        return -1;
    }

    public static int sum (List<Integer> list, int i)
    {
        if (i == list.size())
            return 0;
        else
            return list.get(i) + sum(list, i+1);
    }


    public static int summer(List<Integer> list, int start){
        int right = 0;
        int left = 0;

        if(start == list.size()){
            return 0;
        } else {

            int mid = list.size() / 2;
            if(start < mid){
                left += list.get(start) + summer(list.subList(0, mid), start+1);
            } else if(mid < list.size()){
                right += list.get(mid) + summer(list.subList(mid+1, list.size()), mid+1);
            }
        }
        return right + left;
    }


}

Answer 1

首先，如果你需要做的只是使用递归，你不需要将列表切成两半。列表元素的总和是其第一个元素的总和+列表其余元素的总和。

其次，你的方法过于复杂。如果列表为空，则列表元素的总和为0，唯一元素是包含1个元素，如果它包含多于1，则应用于两个子列表的方法结果的总和。需要任何开始论证。

这应该让你开始。

编辑：自从Oscar Lopez给你答案，但我发现它太复杂了，这是我的：

public static int sum(List<Integer> list) {
    if (list.isEmpty()) {
        return 0;
    }
    else if (list.size() == 1) {
        return list.get(0);
    }
    else {
        int half = list.size() / 2;
        return sum(list.subList(0, half)) + sum(list.subList(half, list.size()));
    }
}

Answer 2

您确定必须拆分列表吗？通常，当你完成家庭作业的这个任务时，意思就像：

public static int sum(List<Integer> l,int start) {
if (start==l.size()) return 0;
return l.get(start)+sum(l,start+1);
}

Answer 3

在递归中发送start + 1时，您错过了列表元素。

     left += list.get(start) + summer(list.subList(0, mid), start+1);

你应该发送

      left += list.get(0) + summer(list.subList(1, mid), 0);

和

      right += list.get(mid) + summer(list.subList(mid+1, list.size()), 0);

我没有看到发送任何起始值的必要性。每次递归都应该以0代替开始。

Answer 4

我认为可以通过跟踪范围的第一个和最后一个索引以更简单的方式解决，如下所示：

public static int sum(List<Integer> list, int i, int j) {
    if (i == j)
        return list.get(i);
    int half = (i + j) / 2;
    return sum(list, i, half) + sum(list, half + 1, j);
}

它被称为：

List<Integer> list = Arrays.asList(1, 2, 3);
System.out.println(sum(list, 0, list.size()-1));

它适用于非空列表。如果列表为空，则需要在调用sum之前进行检查。

Answer 5

对于两个基本情况，Ii更容易，如果使用子列表，则不需要额外的'start'参数。（因为这是家庭作业，我不会填写细节。）

public static int summer(List<Integer> list) {
   //base 1
   if (list.size() == 0) {

   }
   //base 2
   else if (list.size() == 1) {

   }
   else
   {
      //no need for if statements now!
      int left = summer(list.sublist(/* */))
      int right = summer(list.sublist(/* */))
      return left + right;
   }
}

Answer 6

我想知道获得“一半”名单的原因。问题的解决方案是独一无二的：

public int sum_list(List<Integer> list) {
    if (list == null || list.isEmpty()) {
        return 0;
    }
    return list.remove(0) + sum_list(list);
}

Answer 7

import java.util.*;

public class SumListByRecursion {

    public static int sumByRec(List<Integer> list) {


        int size = list.size();
        if(size > 0) {
            return list.get(0) + sumByRec(list.subList(1, size));           
        }
        return 0;
    }


    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List<Integer> list = new ArrayList<Integer>();

        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        System.out.println("List:"+" "+list);

        int sum = sumByRec(list);
        System.out.println("Sum of the list:"+" "+sum);
    }

}

List的总和<integer>递归</integer>

7 个答案: