Invertir elementos de una lista usando recursividad

El objetivo es escribir un código que invierta los elementos de una lista con la ayuda de la recursividad.

public static List<Integer> reverse(List<Integer> input) {
    if (input.isEmpty()) {
        return new LinkedList<Integer>();
    } else {
        List<Integer> output = new LinkedList<Integer>();
        output.add(((LinkedList<Integer>) input).removeLast());
        reverse(input);
        return output;
    }
}

Desafortunadamente, solo estoy obteniendo el primer elemento correcto, el resto de la lista simplemente no aparece. ¿Qué me estoy perdiendo?

Respuesta 1

Puede hacer esto como en el siguiente código. Tenga en cuenta que estoy usando el removeFirst()método.

import java.util.LinkedList;
import java.util.List;

public class Reverse {

  public static List<Integer> reverse(List<Integer> input) {
    if (input.isEmpty()) {
      return new LinkedList<Integer>();
    } else {
      Integer first = ((LinkedList<Integer>) input).removeFirst();
      List<Integer> output = reverse(input);
      output.add(first);
      return output;
    }
  }

  public static void main(String[] args) {

    List<Integer> input = new LinkedList<>();
    input.add(15);
    input.add(37);
    input.add(26);
    input.add(18);
    input.add(31);

    System.out.println("Input  : " + input);
    System.out.println("Output : " + reverse(input));
  }
}
Respuesta: 2

Como se mencionó en los comentarios, necesita un segundo parámetro y probablemente no necesita un valor de retorno:

public static void reverse(List<Integer> input, List<Integer> output) {
    if (input.isEmpty()) {
        return;
    }
    output.add(((LinkedList<Integer>) input).removeLast());
    reverse(input, output);
}

Uso:

List<Integer> input = new LinkedList<>();
// fill it with values
List<Integer> output = new LinkedList<>();

reverse(input, output);
System.out.println(output);
Respuesta: 3

Estoy usando para convencer a un Stack por su método pop.

public static List<Integer> reverse(List<Integer> input) {
    Stack<Integer> stack = new Stack();
    stack.addAll(input);
    return reverse(stack,new LinkedList<>());
  }

  public static List<Integer> reverse(Stack<Integer> input,LinkedList<Integer> output) {
     if (input.isEmpty()) {
       return output;
     }
     output.addFirst(input.pop());
     reverse(input, output);
    return output;
  }

Si desea omitir la nueva adición de los elementos, necesita mantener un índice, o usar una LinkedList que tenga en cuenta el primer y el último elemento. Aquí es con el mantenimiento del índice y una API de Lista pura:

public static List<Integer> reverse(List<Integer> input) {


     return reverse(input,new LinkedList<>(),0);
  }

  public static List<Integer> reverse(List<Integer> input,LinkedList<Integer> output,int index) {
     if (index == input.size()) {
       return output;
     }
     output.addFirst(input.get(index));
     reverse(input, output,++index);
    return output;
  }
Respuesta: 4

No puedo encontrar la sintaxis correcta de la siguiente consulta en Java, por favor, ayúdenme. String st = "SELECT COUNT ('" + id + "') FROM '" + selected_table + "'"; String st = "SELECT COUNT ('" + id + "') FROM '" + ...

Recientemente, algunos dispositivos dejan de funcionar con los componentes de la vista web, detecté que Android 8 y Android 6 o pocos funcionan bien, pero en dispositivos con Android 7 o 9 no se muestra texto. Este problema ...

Soy nuevo en Java 8 y Streams Collectors tratando de entender cuál es la diferencia básica entre los dos. Porque tanto el código arroja los mismos resultados. Uno usa return groupingBy (clasificador, toList () ...

Tengo la siguiente biblioteca compartida JNI ubicada en / data / subv / Mem, he configurado LD_LIBRARY_PATH en: LD_LIBRARY_PATH = / data / subv / Mem que contiene dos archivos: bmemBridgelib.so y memBridgelib ...