【数组求和】Java语言 (递归实现)

代码示例:

    public static void main(String[] args) {
        int[] arr = {2,4,6};
        int n = 0;
        int m = arr.length-1;
        System.out.println(GetSum(arr));
        System.out.println(GetSum1(arr,n));
        System.out.println(GetSum2(arr,m));
        System.out.println(GetSum3(arr,0,2));
    }
    public static int GetSum(int[] arr){
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum +=arr[i];
        }
        return sum;
    }

    /**
     * 从零索引位置往后加
     * @param arr
     * @param begin 数组的起始索引,++begin 不停的让begin往后移动,直到移到索引最大的位置。
     * @return       GetSum(arr,0)
     *                  arr[0]+GetSum1(arr,1)
     *                           arr[1]+GetSum1(arr,2)
     *                                    return arr[2];
     */
    public static int GetSum1(int[] arr,int begin){
        //基线条件
        if(begin==arr.length-1) return arr[begin];

        return arr[begin]+GetSum1(arr,++begin);
    }

    /**
     * 从后往前倒着加
     * @param arr
     * @param end  数组的最后一个索引, --end 不停的让end往前移动,直到移到索引0位置。
     * @return   进行递归 Get(arr,2)
     *                    arr[2]+GetSum(arr,1)
     *                             arr[1]+GetSum(arr,0)
     *                                       return arr[0];
     */
    public static int GetSum2(int[] arr,int end){
        //基线条件
        if(end==0) return arr[end];

        return arr[end]+GetSum2(arr,--end);
    }

    /**
     *数组部分求和------指定从那个索引加到那个索引。
     * @param arr
     * @param begin ----指定的起始索引
     * @param end   ----指定的结束索引
     * @return     让 begin往后移动 ++begin
     *               GetSum(arr,0,2)
     *                  arr[0]+GetSum3(arr, 1, 2)
     *                            arr[1]+GetSum3(arr, 2, 2)
     *                                     return arr[2]
     *             让 end 往前移动 --end
     *               GetSum(arr,0,2)
     *                  arr[2]+GetSum3(arr, 0, 1)
     *                           arr[1]+GetSum3(arr, 0, 0)
     *                                     return arr[0]
     */
    public static int GetSum3(int[] arr,int begin,int end){
        //基线条件
        if(begin==end) return arr[end];//return arr[begin]
        //return arr[begin]+GetSum3(arr, ++begin, end);
        return arr[end]+GetSum3(arr, begin, --end);
    }

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 斐波那契数列是一个数列,其中第 i 个数是前两个数之和。通常以下标从 0 开始,第 0 个数是 0,第 1 个数是 1。因此,斐波那契数列的前几项如下所示: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ... 要求斐波那契数列的求和,可以使用递归的方法,并使用缓存来解决重复计算的问题。 下面是一个使用 Java 语言实现的示例代码: ``` import java.util.HashMap; import java.util.Map; public class FibonacciSum { // 创建缓存 private static Map<Integer, Integer> cache = new HashMap<>(); public static void main(String[] args) { System.out.println(fibonacciSum(10)); // 143 } // 计算斐波那契数列的求和 public static int fibonacciSum(int n) { // 如果在缓存中找到了结果,直接返回 if (cache.containsKey(n)) { return cache.get(n); } // 如果 n 是 0 或 1,直接返回 if (n == 0 || n == 1) { return n; } // 否则,使用递归计算斐波那契数列的求和 int sum = fibonacciSum(n - 1) + fibonacciSum(n - 2); // 将结果放入缓存中 cache.put(n, sum); return sum; } } ``` 在这段代码中,我们使用了一个 `Map` 来缓存斐波那契数列的结果。每次调用 `fibonacciSum` 方法时,我们首先检查缓存 ### 回答2: 斐波那契数组是一个数列,其中每个数都是前两个数的和。首先,我们需要定义一个递归函数来生成斐波那契数列,然后使用缓存方法来优化计算过程,以避免重复计算。 在Java中,我们可以这样实现斐波那契数组求和递归函数: ```java public int fibonacci(int n) { if (n <= 0) { return 0; } else if (n == 1 || n == 2) { return 1; } else { return fibonacci(n - 1) + fibonacci(n - 2); } } ``` 上面的代码中,我们首先判断n的值,如果n小于等于0,则返回0;如果n等于1或2,则返回1。否则,我们就通过递归调用函数来计算前两个数的和。 然而,上述的递归实现会存在重复计算的问题,因为在计算较大的斐波那契数时,需要多次计算相同的子问题。为了优化计算过程,我们可以使用缓存方法,将每个已经计算过的子问题的结果保存起来,避免重复计算。 下面是使用缓存方法来实现斐波那契数组求和的代码: ```java public int fibonacciWithCache(int n, Map<Integer, Integer> cache) { if (n <= 0) { return 0; } else if (n == 1 || n == 2) { return 1; } else if (cache.containsKey(n)) { return cache.get(n); } else { int result = fibonacciWithCache(n - 1, cache) + fibonacciWithCache(n - 2, cache); cache.put(n, result); return result; } } ``` 上述代码中,我们增加了一个缓存参数cache,它是一个键值对的映射,用于保存每个已经计算过的斐波那契数的值。首先,我们判断cache中是否已经存在n的计算结果,如果存在,则直接返回;否则,我们就通过递归调用函数来计算前两个数的和,并将结果保存到缓存中。 通过使用缓存方法,我们可以避免重复计算,从而提高斐波那契数组求和的效率。 ### 回答3: 斐波那契数列是一个经典的数列,从第三项开始,每一项都是前两项的和。为了求解斐波那契数列的和,我们可以使用递归缓存方法。 在递归缓存方法中,我们定义一个数组用来保存计算过的结果,这样可以避免重复计算,提高效率。 首先,我们创建一个长度为n+1的数组来保存斐波那契数列的值,其中n表示要求和的斐波那契数列的项数。然后,我们将数组的前两个元素设为0和1,表示斐波那契数列的前两项。 接下来,我们定义一个递归函数来计算斐波那契数列的和。在函数中,我们首先判断当前要计算的项数是否已经计算过,如果是,则直接返回数组中保存的值。如果没有计算过,则调用递归函数来计算当前项的值,并将结果保存在数组中,然后返回计算结果。 最后,我们调用递归函数来计算斐波那契数列的和,并将结果返回。 以下是使用Java编写的代码示例: ```java public class FibonacciSum { public static void main(String[] args) { int n = 10; // 求和的斐波那契数列的项数 int sum = fibonacciSum(n); System.out.println("斐波那契数列的前" + n + "项的和为:" + sum); } public static int fibonacciSum(int n) { int[] fibonacci = new int[n + 1]; fibonacci[0] = 0; fibonacci[1] = 1; return fibonacciSumHelper(n, fibonacci); } public static int fibonacciSumHelper(int n, int[] fibonacci) { if (fibonacci[n] != 0) { return fibonacci[n]; } fibonacci[n] = fibonacciSumHelper(n - 1, fibonacci) + fibonacciSumHelper(n - 2, fibonacci); return fibonacci[n]; } } ``` 以上代码通过递归缓存的方式来求解斐波那契数列的和,使用了动态规划思想,在计算过程中避免了重复计算,提高了效率。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值