Рекурсивный метод не правильно выполняется

Question

У меня есть назначение программирования для вводного уровня Java-класса (проблема суммирования подмножества) - по какой-то причине мой рекурсивный метод не выполняется должным образом (он просто идет прямо до конца метода и распечатывает отсортированный список). Любая помощь будет оценена по достоинству - я новичок, а рекурсивные функции действительно запутывают меня.

package programmingassignment3; 

import java.io.*; 
import java.util.*; 

public class ProgrammingAssignment3 { 

    static int TARGET = 10; 
    static ArrayList<Integer> list = new ArrayList<>(); 
    static int SIZE = list.size(); 

    public static void main(String[] args) { 
     populateSortSet(); 
     sumInt(list); 
     recursiveSS(list); 
    }//main 

    public static void populateSortSet() { 
     try { 
      File f = new File("set0.txt"); 
      Scanner input = new Scanner(f); 
      while (input.hasNext()) { 
       int ele = input.nextInt(); 
       if (ele < TARGET && !list.contains(ele)) { 
        list.add(ele); 
       }//if 
      }//while 
      Collections.sort(list); 
     }//try 
     catch (IOException e) { 
      e.printStackTrace(); 
     }//catch 
    }//populateSet 

    public static void recursiveSS(ArrayList<Integer> Alist) { 
     if (Alist.size() == SIZE) { 
      if (sumInt(Alist) == TARGET) { 
       System.out.println("The integers that equal " + TARGET + "are: " + Alist); 
      } //if==TARGET 
     }//if==SIZE 
     else { 
      for (int i = 0; i < SIZE; i++) { 
       ArrayList<Integer> list1 = new ArrayList<>(Alist); 
       ArrayList<Integer> list0 = new ArrayList<>(Alist); 
       list1.add(1); 
       list0.add(0); 
       if (sumInt(list0) < TARGET) { 
        recursiveSS(list0); 
       }//if 
       if (sumInt(list1) < TARGET) { 
        recursiveSS(list1); 
       }//if 
      }//for 
     }//else 
     System.out.println("echo" + Alist); 
    }//recursiveSS 

    public static int sumInt(ArrayList<Integer> Alist) { 
     int sum = 0; 
     for (int i = 0; i < SIZE - 1; i++) { 
      sum += Alist.get(i); 
     }//for 
     if (Alist.size() == TARGET) { 
      sum += Alist.get(Alist.size() - 1); 
     }//if 
     return sum; 
    }//sumInt 
}//class 

Answer 1

Вот как я это сделаю. Надеюсь, он уточнит условие остановки и рекурсию. Как вы можете видеть, статические методы не являются проблемой:

import java.util.ArrayList; 
import java.util.List; 

/** 
* Demo of recursion 
* User: mduffy 
* Date: 10/3/2014 
* Time: 10:56 AM 
* @link http://stackoverflow.com/questions/26179574/recursive-method-not-properly-executing?noredirect=1#comment41047653_26179574 
*/ 
public class RecursionDemo { 

    public static void main(String[] args) { 
     List<Integer> values = new ArrayList<Integer>(); 
     for (String arg : args) { 
      values.add(Integer.valueOf(arg)); 
     } 
     System.out.println(String.format("input values : %s", values)); 
     System.out.println(String.format("iterative sum: %d", getSumUsingIteration(values))); 
     System.out.println(String.format("recursive sum: %d", getSumUsingRecursion(values))); 
    } 

    public static int getSumUsingIteration(List<Integer> values) { 
     int sum = 0; 
     if (values != null) { 
      for (int value : values) { 
       sum += value; 
      } 
     } 
     return sum; 
    } 

    public static int getSumUsingRecursion(List<Integer> values) { 
     if ((values == null) || (values.size() == 0)) { 
      return 0; 
     } else { 
      if (values.size() == 1) { // This is the stopping condition 
       return values.get(0); 
      } else { 
       return values.get(0) + getSumUsingRecursion(values.subList(1, values.size())); // Here is recursion 
      } 
     } 
    } 
} 

Вот так я использовал, чтобы проверить:

input values : [1, 2, 3, 4, 5, 6] 
iterative sum: 21 
recursive sum: 21 

Process finished with exit code 0 

Answer 2

Эта вещь, что вы делаете на уровне класса:

static ArrayList<Integer> list = new ArrayList<>(); 
static int SIZE = list.size(); 

означает, что размер будет инициирована в 0 и остаться 0

(даже если добавить элементы в список.) Это означает, что код внутри for-loop будет выполняться 0 раз.

Попробуйте что-то вроде:

public class ProgrammingAssignment3 { 
    private static int initialSize; 

    //... 
    public static void populateSortSet() { 
     //populate the list 
     initialSize = list.size(); 
    } 

Таким образом, вы не установите значение переменной размера, пока список не будет на самом деле заполняется.

Это говорит о том, что в вашем коде есть еще несколько странных вещей, поэтому я думаю, вам нужно точно указать, что вы пытаетесь решить здесь.

Answer 3

Спасибо всем. Я очень ценю помощь. Я сделал выяснить проблему и решение следующим образом (закрывающая скобка комментарии удалены для чтения удовольствие от @duffymo):

public class ProgrammingAssignment3 { 

    static int TARGET = 6233; 
    static ArrayList<Integer> set = new ArrayList<>(); 
    static int SIZE; 
    static int count = 0; 

    public static void populateSortSet() { 
     try { 
      File f = new File("set3.txt"); 
      Scanner input = new Scanner(f); 
      while (input.hasNext()) { 
       int ele = input.nextInt(); 
       if (ele < TARGET && !set.contains(ele)) { 
        set.add(ele); 
       } 
      } 
      Collections.sort(set); 
      SIZE = set.size(); 
      System.out.println("The original sorted set: " + set + "\t subset sum = " + TARGET); 
     } 
     catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 

    public static void recursiveSS(ArrayList<Integer> list) { 
     if (list.size() == SIZE) { 
      if (sumInt(list) == TARGET) { 
       System.out.print("The Bit subset is: " + list + "\t"); 
       System.out.println("The subset is: " + getSubset(list)); 
       count++; 
      } 
     } 
     else { 
      ArrayList<Integer> list1 = new ArrayList<>(list);//instantiate list1 
      ArrayList<Integer> list0 = new ArrayList<>(list);//instantiate list0 
      list1.add(1); 
      list0.add(0); 
      if (sumInt(list0) <= TARGET) { 
       recursiveSS(list0); 
      } 
      if (sumInt(list1) <= TARGET) { 
       recursiveSS(list1); 
      } 
     } 
    } 

    public static int sumInt(ArrayList<Integer> list) { 
     int sum = 0; 
     for (int i = 0; i < list.size(); i++) { 
      if (list.get(i) == 1) { 
       sum += set.get(i); 
      } 
     } 
     return sum; 
    } 

    public static ArrayList<Integer> getSubset(ArrayList<Integer> list) { 
     ArrayList<Integer> l = new ArrayList<>(); 
     for (int i = 0; i < list.size(); i++) { 
      if (list.get(i) == 1) { 
       l.add(set.get(i)); 
      } 
     } 
     return l; 
    } 
}