Java rekursiv ein array umkehren

Ich habe nicht gefunden was mit der spezifischen Bedürfnisse meiner Funktion, dies zu tun, ja, es ist für die Hausaufgaben.

Also ich habe:

public void reverseArray(int[] x) {

}

Voraussetzung: x.Länge > 0

Die Tatsache, dass ich kann nicht die Funktion haben, etwas zurückzugeben, und das einzige argument ein array ist, lässt mich ratlos.

Ich habe versucht, mit Hilfe von loops zusammen mit der Rekursion, aber ich habe alles versucht, scheint am Ende mit der unendlichen Instanzen der Funktion gemacht werden.

Ich habe eine Idee/Vorschlag, eine andere Funktion, die zusammen mit diesen ein, aber, wie die original-rekursiv ist mir ein Rätsel im moment.

Jede Hilfe ist willkommen.

Sie können ändern Sie die Daten in das array auf Ihre Methode. Es ist nichts falsch Rückgängigmachen eines Arrays in einer Methode, die nichts zurückgibt. Es wäre gut, poste deine Idee und die wir gerne geben Sie Ratschläge (nicht code) von dort.
By the way, können Sie fügen Sie einen anderen parameter auf Ihre reverseArray Methode?
Wir können nicht fügen Sie einen weiteren parameter, wenn das so war, weiß ich, wie ich es tun würde. Und ja, helper-Methoden, die erwähnt wurden, als eine sinnvolle option, ich bin nur nicht sicher, wie das umgesetzt würde.
zusätzliche Parameter sind verboten, denke ich.
Wenn Sie nicht haben keine zusätzlichen Parameter (und Sie nicht haben, können zusätzliche Elemente, die im array zu handeln, wie Parameter) und Sie können keine Kopien erstellen, der das array dann können Sie es nicht. Wenn Sie Kopien machen zu können (und die Verwendung von System.arraycopy), dann kannst du es tun, indem Sie kürzer und kürzer Kopien des Arrays.

InformationsquelleAutor | 2012-10-31

8

Wenn ich die Codierung wurden diese, ich würde erstellen Sie einen temporären array (vielleicht mit einem element entfernt?) für den rekursiven aufrufen und kopieren Sie Elemente wieder in das original-array vor der Rückgabe aus der Funktion. Sie müssen auch zu finden, ein base-case-zum beenden der Rekursion.

+1 Das temporäre array, das übergeben wird, um reverseArray wird ein element kürzere jedem Schritt (so, dass die Rekursion wird beendet, wenn N Schritte).
Beschloss ich, meine ursprüngliche Antwort hatte zu viele details, so schrieb ich es.
Ich hatte das als Idee, ich war einfach nicht sicher, wie es zu implementieren früher, ich glaube, ich habe es nun herausgefunden. Pass in einer abgespeckten array (ersten und letzten Elemente entfernt) in eine neue Instanz der Funktion, bis die Länge ist 2, wechseln Sie (wenn Länge == 1, nichts tun), und dann von da, an jedem Ende eine Instanz, tack auf die entfernten Elemente, aber eingeschaltet?
Dies brachte mich auf den richtigen Weg, ohne mir zu sagen genau, was Sie tun, sehr geschätzt.
Ich hatte nur im Hinterkopf, entfernen Sie entweder die ersten oder letzten element. Ich mag deine Idee, Sie zu entfernen und wechseln.

InformationsquelleAutor 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
    }   
}

Test:

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

Rekursive O(n), keine temporären Arrays benötigt.

Die oben genannten erfüllt nicht die Restriktion (empfunden), dass man kann nicht haben keine zusätzlichen Argumente. Aber es ist die naheliegendste Lösung für mich (und die, die ich oben vorgeschlagen).

InformationsquelleAutor 卢声远 Shengyuan Lu

6

Denn das ist Ihre Hausaufgaben, schlage ich vor, ein Beispiel :

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

Können Sie ändern : 10 2 3 4 5 6 7 8 9 1

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

.....

Wie Sie sehen, Schritt für Schritt, die Reihenfolge ist "besser" und das problem "kleiner". So, das problem, das Sie lösen sollte abgeschlossen ist :

1) Wie wendet man das rekursive Aufruf für diese Methode. für das ursprüngliche, das Methode ist : reverse(int[] a). so, nach dem ersten Schritt, sollten Sie erstellen Sie ein array b from a[2] --> a[n-1]. und mit reverse(int[] b)`.

2) nach dem reverse b was sollen wir tun, um umzukehren ? Zuweisen von Werten von b wieder zurück zu a.

3) stop-Bedingung : das, was stop-Bedingung ? Sie sehen, die Elemente von array b weniger als Elemente des Arrays ein. So, zu dem Schritt, sollten wir aufhören ?

Hoffe, dies hilft 🙂

Ich habe noch einmal bearbeitet meine Lösung nicht für die Verwendung der Hilfsfunktion. Wenn wir die helper Funktion, wird es besser sein. Aber, ich glaube nicht, dass dein Lehrer so 🙂
Es hat geholfen, vielen Dank.

InformationsquelleAutor hqt

Versuchen Sie etwas, das wie unten:

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);
    }
}

Im wesentlichen der gleiche wie der Vorschlag von @Pogo.
Obwohl es funktioniert, ist diese Art der Umkehr ist schrecklich ineffizient so viele sub-arrays werden erzeugt und gelesen werden. Das macht die Laufzeit von 0(n) 0(n^2)!

InformationsquelleAutor Yogendra Singh

Aufrufen 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));
   }
}

InformationsquelleAutor rashedcs

//Wir sind gerade dabei ein Betrieb hier und den Aufruf einer Hilfsmethode.

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);
}

InformationsquelleAutor WIll

Hier ist der main-Methode:

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;
        }

    }

}

InformationsquelleAutor 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();
}

}

InformationsquelleAutor user1177645

Dies ist wahrscheinlich der einfachste Weg, nicht die Schnellste, aber wahrscheinlich das einfachste.

Ganzes Programm würde wie folgt 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);
    }
}

Hoffe, es hilft!

InformationsquelleAutor juan barrera

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() {
    }
}

InformationsquelleAutor Edmond T Zinzombe

-1

psuedo-code
```
function revarray(a[1...n])
  if a.length == 1 or a.length == 0
    do nothing 
  # return a
  else
     swap a[1] and a[n]
     revarray(a[2...n-1])
  # return a (The function will not return anything but the contents of a are changed)
```
Du hast den code nicht Lesen richtig-es ist ein "void" - Funktion.
Dies ist eine offensichtliche Lösung, aber in Java erfordert den Aufbau einer neuen array und kopieren zu/von es mit dem System.arraycopy, so ein paar Zeilen komplexer als der pseudocode vorgeschlagen.
Warum ist diese Antwort markiert? Es ist das gleiche wie Yogendra Singh (später) der Vorschlag, die bekommen +2 so weit.
Ich weiß nicht, warum es nach unten gekennzeichnet. Denn es ist die erste Antwort, die ich Schätze.
Und warum hat der Kommentar von @Thilo +6, obwohl es falsch ist??

InformationsquelleAutor pogo
-1

Da gibt es keine Anweisung, die Schlaufen dürfen nicht verwendet werden:
```
void reverseArray(int[] x) {
    if (x != null) {
        for (int i = 0; i < length.x / 2; i++) {
            int j = (length.x - 1) - i;
            int temp = x[i];
            x[i] = x[j];
            x[j] = temp;
         }
         reverseArray(null);
     }
}
```
Wahrscheinlich der Schnellste der Menge.

Betrug dies ist.
Als ich im college war, über einen computer wurde manchmal als Betrug. Was auch immer funktioniert!
Dies ist die Schleife, nicht rekursiv.
Der Aufruf der Methode ist rekursiv, aber die eigentliche operation ist nicht.
guter Weg, um zu pissen Lehrerin aus 😀

InformationsquelleAutor Hot Licks

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.