Guardar datos en una función recursiva en una lista

Estoy trabajando en una función que desglosa la entrada dada en denominaciones usando una llamada recursiva.

En cada paso se repite en dos variantes:

1. Continuar con la moneda actual: agréguela a la lista y repita.
2. Cambie a la siguiente moneda: incremente la posición de la moneda y recurse.

Además de imprimir la combinación de denominaciones capturadas en la lista cuando quedan == 0, tengo la intención de capturar el valor de esa lista y devolverlo de la función.

Aquí está el código:

    static final int[] DENOMINATIONS = {9,5,3};

    private static void change(int remaining, List<Integer> coins, int pos)

        if (remaining == 0) {

       // This correctly prints the desired output. 
       // I want to return that exact value from the function.
            System.out.println(coins); 

        } else {
            if (remaining >= DENOMINATIONS[pos]) {
                coins.add(DENOMINATIONS[pos]);
                another.addAll(coins);
                change(remaining - DENOMINATIONS[pos], coins, pos);
                coins.remove(coins.size() - 1);
            }
            if (pos + 1 < DENOMINATIONS.length) {
                change(remaining, coins, pos + 1);
            }
        }
    }


    public static List<Integer> denominations(int amount) {
        List<Integer> result = new ArrayList<Integer>();
        List<Integer> another = new ArrayList<Integer>();
        change(amount, result, another ,0);
        System.out.println(another.size());
        return another;
    }

    public static void main(String[] args) {
        List<Integer> list = denominations(13);
        System.out.println(list);
    }

Salida: [5, 5, 3]

Parece suponer que Java se pasa por referencia, lo que no es cierto. Los métodos Java se pasan por valor.

He actualizado tu código:

método de cambio:

private static List<Integer> change(int remaining, List<Integer> coins, int pos) { // Updated method return type;

    if (pos < 0 || pos >= DENOMINATIONS.length) { // check if position is invalid
        return new ArrayList<>(); // return an empty list
    }

    if (remaining == DENOMINATIONS[pos]) { // check if remaining is equal to denominations[pos]
        coins.add(DENOMINATIONS[pos]); // add the denominations to the coins result
        return coins; // return the result
    } else if (remaining > DENOMINATIONS[pos]) { // check if remaining is greater than denominations[pos]
        coins.add(DENOMINATIONS[pos]);// add the possible denominations to the coins result
        remaining = remaining - DENOMINATIONS[pos]; // calculate the new remaining
        if (remaining >= DENOMINATIONS[pos]) { // check if remaining is greater than or equal to denominations[pos]
            return change(remaining, coins, pos); // stick to this position
        } else {
            return change(remaining, coins, pos + 1); // increment pos to go to the lower denominations
        }
    } else if (remaining < DENOMINATIONS[pos]) { // check if remaining is lesser than denominations[pos]
        if (coins.isEmpty()) { // if coins is empty then go to the next denomination
            return change(remaining, coins, pos + 1);
        } else {
            coins.remove(coins.size() - 1); // remove the previous denomination
            return change(remaining + DENOMINATIONS[pos - 1], coins, pos); // go back to the previous remaining and // try this DENOMINATIONS[pos]
        }
    }
    return coins;
}

método de denominaciones:

public static List<Integer> denominations(int amount) {
    return change(amount, new ArrayList<Integer>(), 0);
}

ENTRADA : 13
SALIDA :[5, 5, 3]

Tendría que agregar return coins;en el changemétodo y, pero puede mantenerlo como lo tiene. Devolver y cambiar una matriz es un olor a código, ya que el método opera en el objeto (lo modifica) y devuelve un resultado.

Para que funcione, puede definir su denominationmétodo de la siguiente manera:

public static List<Integer> denominations(int amount) {
   List<Integer> result = new ArrayList<Integer>();
   change(amount, result, 0);
   return result;
}

Editar:

La lista está vacía porque el único lugar donde ha cambiado es aquí:

coins.add(DENOMINATIONS[pos]);
change(remaining - DENOMINATIONS[pos], coins, pos);
coins.remove(coins.size() - 1);

Donde se agrega y elimina un elemento. Es lo que has escrito lo que lo hace vacío :)

Edit2:

Sugeriría pasar un segundo objeto, que sería una copia de la lista que le gustaría devolver y no se modifica.