Question

应该递归地反转字符串数组。

无法实现此功能。如果我正在使用for循环，我会在数组的末尾开始它并打印出从最后一个元素开始并以第一个元素结束的数组。

我不太清楚如何递归地做到这一点。我正在考虑使用交换，但当我无法弄清楚如何更改我交换的元素时，这种想法就会失败。

任何想法或推动正确的方向都将受到赞赏。

到目前为止，这是最重要的。我知道它的错误，我得到一个错误超出范围的异常，我不知道如何解决。我想我没有正确地交换第一个和最后一个。但我得到了正确的想法吗？

这就是我想出的。 a是一个数组。它在一个班级里面。

// reverse an array 

public void rev() 
{
    rev(0,a.length-1);
} 

private void rev(int first, int last)
{
if(last == 0)
{
//do nothing
}

else
{
while(first != last)
{
int temp = first;
first = last;
last = temp;


System.out.print(" " + a[first]);
rev((first + 1), (last - 1));
}

}
}

进行了一些更改，它会反转最后3个元素，但它会重复第二个元素。我没有if语句来控制它何时运行所以它应该运行直到left = right？

这就是我改为

的原因

// reverse an array 
public void rev() 
{
    rev(0,a.length-1);
} 

private void rev(int first, int last)
{
    if(last == 0)
    {
    //do nothing
    }

    else
    {


    String temp = a[first];
    a[first] = a[last];
    a[last] = temp;

    System.out.print(" " + a[first]);
    rev(first+ 1, last-1);

    }
}

Answer 1

递归的技巧是尝试根据基本情况考虑问题，然后将一切方法减少到基本情况。

所以，如果你试图反转列表，那么你可以这样想：

大小为1的列表的反面就是该列表。
对于size > 1的列表，输出列表中的第一个元素将是输入列表的最后一个元素。
输出列表的其余部分将与输入列表相反，减去最后一个元素。

您现在有了递归定义。

希望有所帮助。

Answer 2

while循环太多了，因为你无论如何都在使用递归，试试这个

private void rev(int first, int last)
{
   if(first < last)
   {
      var temp = a[first];
      a[first] = a[last];
      a[last]  = temp;
      rev(first + 1, last - 1);
   }
}

Answer 3

我总是喜欢使用一个简单的公共方法来调用私有递归方法。从代码中的其他地方开始，你只需要给它数组，而不必担心其他参数。此外，这会捕获空数组，但您仍需要在开始附近的某个位置检查null。如果数组为null，可能会在public方法中抛出异常？

public String[] reverseArray(String[] theArray) {
    this.reverseArrayWorker(theArray, 0, theArray.length -1);
}

private String[] reverseArrayWorker(String[] theArray, int left, int right) {
    // Check your base cases first
    if (theArray.length <= 1) {
        // Array is one element or empty
        return theArray;
    } else if (left - right <= 0) {
        // If there are an odd # of items in the list you hit the center
        // If there are an even number your indexes past each other
        return theArray;
    }
    // Make the recursive call
    this.reverseArrayWorker(theArray, left + 1, right - 1);
    // Switch the two elements at this level
    String temp = theArray[left];
    theArray[left] = theArray[right];
    theArray[right] = temp;
    // Return the array up a level
    return theArray;
}

Answer 4

public int[] reverse(int[] returnMe, int[] original, int curPos){
    if (original.length == 1){
        return original;
    }else{
        if (curPos < original.length){
            returnMe[curPos] = original[original.length - 1 - curPos];
            reverse(returnMe, original, curPos + 1);
        }else{
            return returnMe;
        }
    }
}

Answer 5

这是一个例子（但是没有A String，因为它是家庭作业）但希望它会给你这个想法。

public static List<Character> reverse(List<Character> chars) {
    return chars.isEmpty() ? chars : 
     addToList(chars.get(0), reverse(chars.subList(1, chars.length()));
}

public static T List<T> addToList(T t, List<T> ts) {
    List<T> ret = new ArrayList<T>();
    ret.addAll(ts);
    ret.add(t);
    return ret;
}

Answer 6

这也会奏效。有点类Lisp解决方案。

public static List<String> append(String x, List<String> xs) {
    xs.add(x);
    return xs;
}

public static List<String> reverse(List<String> xs) {
    return xs.isEmpty()
            ? xs
            : append(xs.get(0), reverse(xs.subList(1, xs.size())));
}

I / O：

List          ==> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Reversed list ==> [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

如何递归地反转字符串数组？

6 个答案: