Java, inverser récursivement un tableau
Pour ce faire, je n'ai rien trouvé qui réponde aux besoins spécifiques de ma fonction. Oui, c'est pour les devoirs.
Donc j'ai:
public void reverseArray(int[] x) {
}
Condition: x.length> 0
Le fait que je ne puisse rien renvoyer par la fonction et que le seul argument est qu'un tableau me laisse perplexe.
J'ai essayé d'utiliser des boucles avec la récursivité, mais tout ce que j'ai essayé semble aboutir à des instances infinies de la fonction créée.
J'ai eu une idée/suggestion d'utiliser une autre fonction avec celle-ci, mais, comment utiliser l'original récursivement me dépasse pour le moment.
Toute aide est appréciée.
Si je codais cela, je créerais un tableau temporaire (peut-être avec un élément supprimé?) Pour l'appel récursif et copierais-je les éléments dans le tableau d'origine avant de revenir de la fonction. Vous devrez également trouver un scénario de base pour mettre fin à la récursivité.
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
}
}
Tester:
int[] s = new int[]{1,2,3,4,5};
reverseArray(s);
System.out.println(Arrays.toString(s));//"5,4,3,2,1"
Récursif, O (n), aucun tableau temporaire n'est nécessaire.
Parce que ce sont vos devoirs, je suggère un exemple:
Séquence donnée: 1 2 3 4 5 6 7 8 9 10
Vous pouvez changer en: 10 2 3 4 5 6 7 8 9 1
Après cela: 10 9 3 4 5 6 7 8 2 1
.....
Comme vous le voyez, pas à pas, la séquence est "meilleure" et le problème est "plus petit". Le problème à résoudre est le suivant:
1) Comment appliquer un appel récursif pour cette méthode. pour l'original, la méthode est la suivante: reverse(int[] a). ainsi, après la première étape, vous devriez créer le tableau b from a[2] --> a[n-1]. et en utilisant reverse (int [] b) `.
2) après inversion b, que devrions-nous faire pour inverser a? Attribuez à nouveau les valeurs de b à a.
3) condition d'arrêt: quelle condition d'arrêt? Vous voyez que les éléments du tableau b sont inférieurs aux éléments du tableau a. Alors, à quelle étape devons-nous nous arrêter?
J'espère que cette aide :)
Essayez quelque chose comme ci-dessous:
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);
}
}
Appel de reverseArray (0, n, arr) ici n est la longueur du tableau
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));
}
}
C'est probablement le moyen le plus simple, pas le plus rapide, mais probablement le plus simple.
Tout un programme ressemblerait à quelque chose comme ça:
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);
}
}
J'espère que ça aide!
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() {
}
}
Voici la méthode principale:
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));
}
}
et voici la fonction récursive:
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;
}
}
}
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();
}
}
// Nous ne faisons qu'une opération ici et appelons une méthode d'assistance.
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);
}