Java - Rekursiv zählen Vorkommen eines Wortes in einer Liste

Question

auf der Suche nach einer Hand mit einigen Rekursion, ich weiß, es ist ein einfaches Problem irgendwo, aber nicht sicher, wie/wo!

Hier ist meine rekursive Methode:

public static int getNumAppearances(myList<String> l, String word) 
{ 
    int index = 0; 
    int count = 0; 
    String search = word; 

    if(index > l.my_get_length()-1) 
    { 
     return 0; 
    } 
    else if(l.my_get_element(index).equals(search)) 
    { 
     count++; 
     index++; 
    } 

    return count + getNumAppearances(l, word); 
} 

Prost!

Bearbeiten, myList Klasse:

public interface myList<T> { 

    //------------------------------------------------------------------- 
    // Create an empty MyList: create_empty 
    //------------------------------------------------------------------- 
    //public myList create_empty(); --> Java does not support constructors in interfaces 

    //------------------------------------------------------------------- 
    // Basic Operation --> Get number of elements in MyList: my_get_length 
    //------------------------------------------------------------------- 
    public int my_get_length(); 

    //------------------------------------------------------------------- 
    // Basic Operation --> Get element at of MyList at a concrete position: my_get_element 
    //------------------------------------------------------------------- 
    public T my_get_element(int index) throws myException; 

    //------------------------------------------------------------------- 
    // Basic Operation --> Add element to MyList at a concrete position: my_add_element 
    //------------------------------------------------------------------- 
    public void my_add_element(int index, T element) throws myException; 

    //------------------------------------------------------------------- 
    // Basic Operation --> Remove element of MyList at a concrete position: my_remove_element 
    //------------------------------------------------------------------- 
    public void my_remove_element(int index) throws myException; 

} 

Ich habe erkannt, Sie idealerweise einen Index an die Methode übergeben müssen zu werden, aber das ist leider nicht so, wie er es eingerichtet hat!

Answer 1

Sie können durch Modifizieren der Liste als solche in Ihrer Funktion zählen:

public class RecursiveListWordCount { 

    public static void main(String[] args) { 
     System.out.println(count(Arrays.asList("a", "b", "a", "b", "c"), "d")); 
    } 

    public static final int count(List<String> list, String word) { 
     if(list.isEmpty()) { 
      return 0; 
     } 

     if(list.get(0).equals(word)) { 
      return 1 + count(list.subList(1, list.size()), word); 
     } else { 
      return 0 + count(list.subList(1, list.size()), word); 
     } 

    } 
} 

Bei jedem Aufruf, ich überprüfen, ob die Liste leer ist, wenn true I 0 zurück (als eine leere Liste nicht sicher hat Wort darin, das gleich sein kann).

Der nächste Anruf würde dann eine Unterliste hinzufügen und das gerade überprüfte Wort entfernen.

Hoffnung, dass

Artur

Answer 2

Es scheint, dass Sie die index Variable falsch nutzen sind, weil Sie immer Überprüfung der gleiche index jedes Mal, wenn die Methode nennt sich sind, dann würde ich empfehlen, die index als Parameter an die Methode. Anstatt eine count Variable zu speichern, können wir einfach das Ergebnis 1 hinzufügen, jedes Mal, wenn wir eine Übereinstimmung finden.

public static int getNumAppearances(List<String> list, String word, int index) 
{  if(list == null || list.size() == 0 || index < 0) return -1; // you can throw an exception instead if you deem it necessary. 
     if(index > list.size() - 1) return 0; 
     else if(list.get(index).equals(word)) return 1 + getNumAppearances(list, word, index + 1); 
     return getNumAppearances(list, word, index + 1); 
} 

not - beim Aufruf der Methode, stellen Sie sicher, dass Sie 0 als Argument für die index Parameter übergeben, da dieser Ansatz von Anfang an bis zum Ende die Liste untersucht.