webentwicklung-frage-antwort-db.com.de

Java, rekursiv ein Array umkehren

Ich habe nichts gefunden mit den spezifischen Bedürfnissen meiner Funktion, dies zu tun, ja, es ist für Hausaufgaben.

Also habe ich:

public void reverseArray(int[] x) {

}

Voraussetzung: x.Länge> 0

Die Tatsache, dass die Funktion nichts zurückgeben kann, und das einzige Argument ist, dass ein Array mich stumm macht.

Ich habe versucht, Loops zusammen mit der Rekursion zu verwenden, aber alles, was ich versucht habe, scheint bei unendlich vielen Instanzen der Funktion zu enden.

Ich habe eine Idee/Vorschlag bekommen, eine andere Funktion zusammen mit dieser zu verwenden, aber wie das Original rekursiv verwendet werden kann, liegt mir momentan nicht.

Jede Hilfe wird geschätzt.

12
user1787213

Wenn ich das programmieren würde, würde ich ein temporäres Array (vielleicht mit einem entfernten Element?) Für den rekursiven Aufruf erstellen und Elemente in das ursprüngliche Array kopieren, bevor ich von der Funktion zurückkehrte. Sie müssen auch einen Basisfall finden, um die Rekursion zu beenden.

8
Code-Apprentice
void reverseArray(int[] x){
   reverse(x, 0, x.length -1);
}

void reverse(int[] x, int i, int j){
    if(i<j){//Swap
       int tmp = x[i];
       x[i] = x[j];
       x[j] = tmp;
       reverse(x, ++i, --j);//Recursive
    }   
}

Prüfung:

int[] s = new int[]{1,2,3,4,5};
reverseArray(s);
System.out.println(Arrays.toString(s));//"5,4,3,2,1"

Rekursiv, O (n), kein temporäres Array erforderlich.

Da dies Ihre Hausaufgaben sind, schlage ich ein Beispiel vor: 

Gegebene Reihenfolge: 1 2 3 4 5 6 7 8 9 10

Sie können wechseln zu: 10 2 3 4 5 6 7 8 9 1

Danach: 10 9 3 4 5 6 7 8 2 1

.....

Wie Sie Schritt für Schritt sehen, ist die Reihenfolge "besser" und das Problem ist "kleiner". Das Problem, das Sie lösen sollten, ist:

1) So wenden Sie einen rekursiven Aufruf für diese Methode an. Für das Original lautet die Methode: reverse(int[] a). Deshalb sollten Sie nach dem ersten Schritt das Array b from a[2] --> a[n-1] erstellen. und mit reverse (int [] b) `.

2) Was müssen wir tun, um a nach reverse b umzukehren? Weisen Sie wieder Werte von b zu a zu.

3) Stoppbedingung: Welche Stoppbedingung? Sie sehen, dass Elemente von Array b weniger als Elemente von Array a sind. Also, zu welchem ​​Schritt sollten wir aufhören?

Ich hoffe das hilft :)

6
hqt

Versuchen Sie etwas wie folgt:

public void reverseArray(int[] x) {
    if(x.length ==2){
      //if two elements, swap them
      int first = x[0];
      x[0] = x[1];
      x[1] = first;
    }else if(x.length > 2){
      //swap first and last
      int first = x[0];
      x[0]= x[x.length-1];
      x[x.length-1] = first;
      //create a copy of middle elements
      int [] copy = new int[x.length-2];
      System.arraycopy( x, 1, copy, 0, x.length-2);
      //recursive call for middle elements
      reverseArray(copy);
      //place the reversed elements back in the original array
      System.arraycopy( copy, 0, x, 1, copy.length);
    }
}
1
Yogendra Singh

Der Aufruf von reverseArray (0, n, arr) hier ist n die Länge des Arrays

public void reverseArray(int i, int n, int [] arr)
{
   if(i==n)
   {
     return ;
   } 
   else
   {
     reverseArray(i+1, n, arr);
     System.out.println(arr.at(i));
   }
}
1
rashedcs

Dies ist wahrscheinlich der einfachste Weg, nicht der schnellste, aber wahrscheinlich der einfachste.

Ein ganzes Programm würde ungefähr so ​​aussehen:

public static void main(String [] args)
{
    BackwardsArray back = new BackwardsArray();
}

public BackwardsArray()
{
    int [] a = {1,2,3,4,5,6,7,8,9};
    printBackwards(a);
}

void printBackwards( int [] b)
{
    print(b,b.length-1);
}

void print(int [] b, int pos)
{
    System.out.println(b[pos]); // prints last item
    if(pos != 0)
    {
        print(b,pos-1);
    }
}

Ich hoffe es hilft!

0
juan barrera
private static void reversePrint(int[] numbers)
{
    if(numbers.length==0) {
        return;
    }
    int[] a = new int[numbers.length -1];
    for(int i =0;i<numbers.length-1;i++) {
        a[i] = numbers[i+1];
    }
    reversePrint(a);
    System.out.println(numbers[0]+" ");

}
0
chetan007
public class RecursiveArray {


   public static int[] backWardArray(int[] arr, int start, int end) {

       if (start < end) {
           int temp = arr[start];
           arr[start] = arr[end];
           arr[end] = temp;
           backWardArray(arr, start + 1, end - 1);
       }
       return arr;
   }

    public static void main(String[] args) {
        int [] arr = {12,4,6,8,9,2,1,0};
    int [] reversedArray= backWardArray(arr, 0, arr.length-1);
    //loop through the reversed array
        for (int i: reversedArray) {
            System.out.println(i);
        }
    }

    public RecursiveArray() {
    }
}
0

Hier ist die Hauptmethode:

package main;

public class Main {
    public static void main(String[] args) {
        StringOps ops = new StringOps();
        String string = "Arjun";
        // reversing the string recrusively
        System.out.println(ops.reverseRecursively(string.toCharArray(), 0));
    }
}

und hier ist die rekursive Funktion:

package main;

public class StringOps {
    public char[] reverseRecursively(char[] array, int i) {
        char[] empty = new char[0];
        if (array.length < 1) {
            System.out.println("you entered empty string");
            return empty;
        }
        char temp;
        temp = array[i];
        array[i] = array[array.length - 1 - i];
        array[array.length - 1 - i] = temp;
        i++;

        if (i >= array.length - 1 - i) {
            return array;
        } else {
            reverseRecursively(array, i);
            return array;
        }

    }

}
0
Arjun Thakur
public class FunWithAlgorthims {


public static void main(final String[] args) {

    String[] array = {"a", "b", "c", "d"};
    printArray(array);
    revereArrayRecusrive(array, 0);
    printArray(array);
}


public static void revereArrayRecusrive(final String[] array, int startPointer) {
    if (startPointer >= (array.length / 2)) {
        return;
    }
    String temp = array[startPointer];
    array[startPointer] = array[array.length - 1 - startPointer];
    array[array.length - 1 - startPointer] = temp;
    revereArrayRecusrive(array, ++startPointer);
}

public static void printArray(final String[] array) {
    Arrays.stream(array).forEach(a -> System.out.print(a + " "));
    System.out.println();
}

}

0
user1177645

// Wir machen hier nur eine Operation und rufen eine Hilfsmethode auf.

public void reverseArray(int[] nums){
  int[] hold = new int[nums.length]; //just so it will take this argument
  int[] reversed = recurReverseArray(nums, hold, nums.length - 1, 0);
  nums = reversed; //not returning just changing nums to be reversed.
}
public int[] recurReverseArray(int[] nums, int[] reverse, int end, int start){
  if(end == 0 && start == nums.length - 1){
  reverse[start] = nums[end];
  return reverse; //the way out.
  }
  reverse[start] = nums[end];
  return recurReverseArray(nums, reverse, end - 1, start + 1);
}
0
WIll