web-dev-qa-db-fra.com

somme récursivement les entiers dans un tableau

J'essaie de créer pour la classe un programme qui renvoie la somme de tous les entiers d'un tableau à l'aide de la récursivité. Voici mon programme à ce jour:

public class SumOfArray {

private int[] a;
private int n;
private int result;

    public int sumOfArray(int[] a) {

      this.a = a;
      n = a.length;

      if (n == 0)  // base case
      result = 0;
      else
          result = a[n] + sumOfArray(a[n-1]);

      return result;

   } // End SumOfArray method

} // End SumOfArray Class

Mais je reçois trois erreurs qui sont toutes liées, je crois, mais je ne peux pas comprendre pourquoi elle trouve un type de null:

SumOfArray.Java:25: sumOfArray(int[]) in SumOfArray cannot be applied to (int)
    result = a[n] + sumOfArray(a[n-1]);
                    ^
SumOfArray.Java:25: operator + cannot be applied to int,sumOfArray
    result = a[n] + sumOfArray(a[n-1]);
              ^
SumOfArray.Java:25: incompatible types
found   : <nulltype>
required: int
    result = a[n] + sumOfArray(a[n-1]);
                  ^
3 errors
javaarraysrecursionsum
6
Maggie S.

La solution est plus simple qu'il n'y paraît, essayez ceci (en supposant un tableau de longueur non nulle):

public int sumOfArray(int[] a, int n) {
    if (n == 0)
        return a[n];
    else
        return a[n] + sumOfArray(a, n-1);
}

Appelez ça comme ça:

int[] a = { 1, 2, 3, 4, 5 };
int sum = sumOfArray(a, a.length-1);
14
Óscar López

Le problème est que a[n-1] est une int, alors que sumOfArray s'attend à un tableau sur int.

Astuce: vous pouvez simplifier les choses en faisant que sumOfArray prenne le tableau et l'index de départ (ou de fin).

5
NPE
a[n-1]

devient l'int à n-1, pas le tableau de 0 à n-1.

essayez d'utiliser 

Arrays.copyOf(a, a.length-1);

au lieu

3
Cruncher

Essayez ceci si vous ne voulez pas passer la longueur du tableau:

private static int sumOfArray(int[] array) {

        if (1 == array.length) {
            return array[array.length - 1];
        }

        return array[0] + sumOfArray(Arrays.copyOfRange(array, 1, array.length));
    }

Bien entendu, vous devez vérifier si le tableau est vide ou non.

1
samach

Comment sur cette solution récursive? Vous créez un sous-tableau plus petit qui contient des éléments de la seconde à la fin. Cette récursivité se poursuit jusqu'à ce que la taille du tableau devienne 1.

import Java.util.Arrays;

public class Sum {
    public static void main(String[] args){
        int[] arr = {1,2,3,4,5};
        System.out.println(sum(arr)); // 15
    }

    public static int sum(int[] array){
        if(array.length == 1){
            return array[0];
        }

        int[] subArr = Arrays.copyOfRange(array, 1, array.length);
        return array[0] + sum(subArr);
    }
}
1
TakaSoft

C'est la seule solution récursive de complexité O (N) .et de paramètre d'entrée A [] uniquement.
 Vous pouvez gérer les cas nulles et vides (longueur 0) de manière spécifique en tant que Son renvoyant 0 dans cette solution. Vous lancez aussi Exception dans ce cas.

/*
 * Complexity is O(N)
 */
public int recursiveSum2(int A[])
{
    if(A == null || A.length==0)
    {
        return 0;
    }
    else
    {
        return recursiveSum2Internal(A,A.length-1);
    }
}
private int recursiveSum2Internal(int A[],int length)
{
    if(length ==0 )
    {
        return A[length];
    }
    else
    {
        return A[length]+recursiveSum2Internal(A, length-1);
    }
}
1
Nick13

a est un tableau int. Donc a[n-1] est une int. Vous passez une int à sumOfArray qui attend un tableau et non une int.

1
Steve Kuo
private static int sum(int[] arr) {
    // TODO Auto-generated method stub
    int n = arr.length;

    if(n==1)
    {
        return arr[n-1];
    }

    int ans = arr[0]+sum(Arrays.copyOf(arr, n-1));

    return ans;
}
0
Amandeep Singh