Java，以递归方式反转数组
我没有找到任何具有我的function的特定需求来做这件事，是的，它是用于家庭作业。
所以我有：
public void reverseArray(int[] x) { } 前提条件：x.length> 0
事实上，我不能让函数返回任何东西，唯一的参数是数组让我感到难过。
我已尝试使用循环和递归，但我尝试过的所有内容似乎最终都会产生无限的函数实例。
我已经有了一个想法/建议使用另一个函数以及这一个，但是，如何递归使用原始文件在我看来是超出我的。
任何帮助表示赞赏。
如果我正在编写这个，我会创建一个临时数组（可能删除了一个元素？），用于递归调用，并在从函数返回之前将元素复制回原始数组。 您还需要找到一个基本案例来终止递归。
void reverseArray(int[] x){ reverse(x, 0, x.length -1); } void reverse(int[] x, int i, int j){ if(i
测试：
int[] s = new int[]{1,2,3,4,5}; reverseArray(s); System.out.println(Arrays.toString(s));//"5,4,3,2,1"
递归，O（n），不需要临时数组。
因为这是你的功课，我建议一个例子：
给定顺序： 1 2 3 4 5 6 7 8 9 10
你可以改为： 10 2 3 4 5 6 7 8 9 1
之后： 10 9 3 4 5 6 7 8 2 1
…..
如您所见，一步一步，序列“更好”，问题是“更小”。 那么，你应该解决的问题是：
1）如何对此方法应用递归调用。 对于原始方法，方法是： reverse(int[] a) 。 所以，在第一步之后，你应该b from a[2] --> a[n-1]创建数组b from a[2] --> a[n-1] 。 并使用reverse（int [] b）`。
2）反向b ，我们该怎么做才能扭转？ 再次将b的值分配回a。
3）停止条件：什么停止条件？ 您会看到数组b的元素少于数组a的元素。 那么，到哪一步，我们应该停下来？
希望这有帮助:)
尝试以下内容：
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); } }
在这里调用reverseArray（0，n，arr）n是数组的长度
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)); } }
//我们只是在这里进行操作并调用辅助方法。
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); }
这是主要方法：
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)); } }
这是递归函数：
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(); }
}
这可能是最简单的方法，不是最快的，但可能是最简单的方法。
整个程序看起来像这样：
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); } }
希望能帮助到你！
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() { } }
伪代码
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)
由于没有声明不能使用循环：
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); } }
可能是最快的。