Question

我有几天的编程考试，所以我只是为了练习而做一些练习。但是，我一直坚持这个问题，我开始怀疑是否可以这样做。 写一个名为arrayReverse的递归方法，它接受一个整数数组并以反向排序的顺序返回所述数组。所以一个例子是：

input: [1,2,3]    
output:[3,2,1]

我无法解决它。我的直觉是取数组的最后一个元素，把它放在开头，我，e：index [0]，然后递归调用数组的其余部分，然后获取新的最后一个元素并将其放在索引[1]上。不幸的是，实现比我想象的更难，但我（为了尝试）编辑了问题，它接受了2个数组，这是我的代码：

import java.util.Arrays;

class Test {

  int[] arrayReverse(int[] m, int[] mReverse) {
    if (m.length == 1) {
        mReverse[mReverse.length - 1] = m[0];
        return mReverse;
    } else {
        int lastNum = m[m.length - 1];
        mReverse[mReverse.length - m.length] = lastNum;
        int[] arrayMinusOne = cropArray(m);
        return arrayReverse(arrayMinusOne, mReverse);
    }
}

int[] cropArray(int[] m) {
    int[] mCropped = new int[m.length - 1];
    for (int i = 0; i < m.length - 1; i++) {
        mCropped[i] = m[i];
    }
    return mCropped;
}

}
  void demo() {

    int[] helpTest4 = new int[]{1, 2, 3};
    int[] emptyArray = new int[helpTest4.length];

    int[] test4 = arrayReverse(helpTest4, emptyArray);
    System.out.println(Arrays.toString(test4));


}

public static void main(String[] args) {
    new Test().demo();
}
}

它完美无缺，但由于两个原因，我对结果不满意：

我无法完全递归。我在cropArray中使用了for循环。
我无法在一个阵列上进行此操作。

如何做到这一点？

Answer 1

选项1：在递归函数中只使用一个参数（数组）

import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;

public class MyClass {
     public static void main(String[] args) {

        int[] arr = {1,2,3,4,5};
        int[] reversed = reverseArray(arr);
        System.out.println(Arrays.toString(reversed));
    }

    public static int[] reverseArray(int[] arr)
    {
        if (arr.length == 0)
            return arr;

        // remove first element   
        int first = arr[0];
        int[] list = Arrays.copyOfRange(arr, 1, arr.length);

        //Calling Function Recursively get reversed array
        int[] returnArr = reverseArray(list);

        //Add original first to the last of the arrayToReturn
        returnArr = Arrays.copyOf(returnArr, returnArr.length + 1);
        returnArr[returnArr.length - 1] = first;

        return  returnArr;
    }
}

<强>选项2：

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

void reverse(int[] x, int i, int j){
    if(i<j){//Swap ith with jth element where i and j are equidistant from ends
       int tmp = x[i];
       x[i] = x[j];
       x[j] = tmp;
       reverse(x, ++i, --j);//Recursive
    }   
}

测试：

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

递归，O（n），不需要临时数组。

Answer 2

我认为这不是一个特别好的问题 - 显然有一种直接而明确的方法可以在没有递归的情况下做到这一点。所以问题几乎没有证明任何有用的递归知识。

那说我相信他们寻求的算法使用了以下事实：

a）反转1长度数组是微不足道的

b）你可以通过将第一个元素附加到最后一个n-1元素的反向来反转n长度数组。

因此，此解决方案的代码看起来比您目前所拥有的要简单得多。

Answer 3

红宝石：

def reverse(a)
  if a.empty?
    return []
  else
    return [a.last] + reverse(a[0..-2]) 
  end
end

a = [1, 2, 3]

reverse(a)

Answer 4

从字面上理解请求，我提出了一个解决方案，只需要一个输入/输出参数的递归函数：

public static void arrayReverse(int[] input)
{
    if (input.length > 0)
    {
        // Store locally the fist element:
        int firstElement=input[0];

        // Creates a sub-array and reverses it:
        int[] input2=new int[input.length - 1];
        System.arraycopy(input, 1, input2, 0, input2.length);
        arrayReverse(input2);

        // Copies back the reversed array into the current array:
        System.arraycopy(input2, 0, input, 0, input2.length);

        // Puts the stored fist element in the last position:
        input[input.length - 1]=firstElement;
    }
}

此解决方案基于堆栈结构，在运行时利用机器调用堆栈，在执行函数时存储本地值

这种递归的基本情况是corse，是空数组。
在通用情况下，函数将本地存储在第一个元素中，然后递归地重新调用自身以反转数组的其余部分，最后，将第一个元素放回到最后一个位置。

编写一个名为recursive的方法，该方法接受一个整数数组并以反向排序的顺序返回所述数组

4 个答案: