如何遞歸地反轉字符串數組？

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. 大小為1的列表的反面就是該列表。
2. 對於size > 1的列表，輸出列表中的第一個元素將是輸入列表的最后一個元素。
3. 輸出列表的其余部分將與輸入列表相反，減去最后一個元素。

現在，您有了遞歸定義。

希望能有所幫助。

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

這也將起作用。 類似於Kinda 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())));
}

輸入/輸出：

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

Answer 5

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 6

這是一個示例（但由於沒有作業，所以沒有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;
}