反轉字符串的就地遞歸解決方案

Question

我正在從 leetcode 的特色教程Recursion I 中學習遞歸基礎知識

第一個練習是反轉一個字符串Reverse String - LeetCode

編寫一個反轉字符串的函數。 輸入字符串作為字符數組char[] 。

不要為另一個數組分配額外的空間，您必須通過使用 O(1) 額外內存就地修改輸入數組來實現。

您可以假設所有字符都由可打印的 ascii 字符組成。

示例 1：

 Input: ["h","e","l","l","o"] Output: ["o","l","l","e","h"]

示例 2：

 Input: ["H","a","n","n","a","h"] Output: ["h","a","n","n","a","H"]

接受的解決方案是

class Solution:
    def reverseString(self, s):
        """
        :type s: str
        :rtype: str
        """
        #base case
        if len(s) <= 1:
            return s
        #recur case 
        elif len(s) >= 2:
            n=len(s)
            return self.reverseString(s[n//2:])+self.reverseString(s[:n//2])

解決方案的兩個問題：

1、不能就地修改

2、遞歸切片字符串代價高昂。

作為改進它的第一步，引入參數lo和hi來存儲索引

class Solution:
    def reverseString(self, s, lo=0, hi=None):
        """
        :type s: str
        :rtype: None
        """
        if hi == None:
            hi = len(s)
      #base case
        if hi <= 1:
            return s

        #recur case 
        elif hi >= 2:
            mid = hi // 2
            left = self.reverseString(s, lo, mid)
            right = self.reverseString(s, mid, hi)
            return left + right               

它報告錯誤

RecursionError：相比之下超出了最大遞歸深度

---

在 0.005 秒內運行 1 次測試

有什么問題？

Answer 1

我正在從leetcode的精選教程Recursion I中學習遞歸基礎知識

第一個練習是反轉字符串Reverse String-LeetCode

編寫一個反轉字符串的函數。 輸入字符串以字符數組char[] 。

不要為另一個數組分配額外的空間，必須通過使用O（1）額外的內存就地修改輸入數組來做到這一點。

您可以假定所有字符都由可打印的ascii字符組成。

范例1：

 Input: ["h","e","l","l","o"] Output: ["o","l","l","e","h"]

范例2：

 Input: ["H","a","n","n","a","h"] Output: ["h","a","n","n","a","H"]

公認的解決方案是

class Solution:
    def reverseString(self, s):
        """
        :type s: str
        :rtype: str
        """
        #base case
        if len(s) <= 1:
            return s
        #recur case 
        elif len(s) >= 2:
            n=len(s)
            return self.reverseString(s[n//2:])+self.reverseString(s[:n//2])

解決方案的兩個問題：

1，不能就地修改

2，遞歸切片字符串很昂貴。

作為改進的第一步，引入了參數lo和hi來存儲索引

class Solution:
    def reverseString(self, s, lo=0, hi=None):
        """
        :type s: str
        :rtype: None
        """
        if hi == None:
            hi = len(s)
      #base case
        if hi <= 1:
            return s

        #recur case 
        elif hi >= 2:
            mid = hi // 2
            left = self.reverseString(s, lo, mid)
            right = self.reverseString(s, mid, hi)
            return left + right               

報告錯誤

RecursionError：比較中超出了最大遞歸深度

---

在0.005秒內進行1次測試

這是什么問題？

Answer 2

我正在從leetcode的精選教程Recursion I中學習遞歸基礎知識

第一個練習是反轉字符串Reverse String-LeetCode

編寫一個反轉字符串的函數。 輸入字符串以字符數組char[] 。

不要為另一個數組分配額外的空間，必須通過使用O（1）額外的內存就地修改輸入數組來做到這一點。

您可以假定所有字符都由可打印的ascii字符組成。

范例1：

 Input: ["h","e","l","l","o"] Output: ["o","l","l","e","h"]

范例2：

 Input: ["H","a","n","n","a","h"] Output: ["h","a","n","n","a","H"]

公認的解決方案是

class Solution:
    def reverseString(self, s):
        """
        :type s: str
        :rtype: str
        """
        #base case
        if len(s) <= 1:
            return s
        #recur case 
        elif len(s) >= 2:
            n=len(s)
            return self.reverseString(s[n//2:])+self.reverseString(s[:n//2])

解決方案的兩個問題：

1，不能就地修改

2，遞歸切片字符串很昂貴。

作為改進的第一步，引入了參數lo和hi來存儲索引

class Solution:
    def reverseString(self, s, lo=0, hi=None):
        """
        :type s: str
        :rtype: None
        """
        if hi == None:
            hi = len(s)
      #base case
        if hi <= 1:
            return s

        #recur case 
        elif hi >= 2:
            mid = hi // 2
            left = self.reverseString(s, lo, mid)
            right = self.reverseString(s, mid, hi)
            return left + right               

報告錯誤

RecursionError：比較中超出了最大遞歸深度

---

在0.005秒內進行1次測試

這是什么問題？

Answer 3

我正在從leetcode的精選教程Recursion I中學習遞歸基礎知識

第一個練習是反轉字符串Reverse String-LeetCode

編寫一個反轉字符串的函數。 輸入字符串以字符數組char[] 。

不要為另一個數組分配額外的空間，必須通過使用O（1）額外的內存就地修改輸入數組來做到這一點。

您可以假定所有字符都由可打印的ascii字符組成。

范例1：

 Input: ["h","e","l","l","o"] Output: ["o","l","l","e","h"]

范例2：

 Input: ["H","a","n","n","a","h"] Output: ["h","a","n","n","a","H"]

公認的解決方案是

class Solution:
    def reverseString(self, s):
        """
        :type s: str
        :rtype: str
        """
        #base case
        if len(s) <= 1:
            return s
        #recur case 
        elif len(s) >= 2:
            n=len(s)
            return self.reverseString(s[n//2:])+self.reverseString(s[:n//2])

解決方案的兩個問題：

1，不能就地修改

2，遞歸切片字符串很昂貴。

作為改進的第一步，引入了參數lo和hi來存儲索引

class Solution:
    def reverseString(self, s, lo=0, hi=None):
        """
        :type s: str
        :rtype: None
        """
        if hi == None:
            hi = len(s)
      #base case
        if hi <= 1:
            return s

        #recur case 
        elif hi >= 2:
            mid = hi // 2
            left = self.reverseString(s, lo, mid)
            right = self.reverseString(s, mid, hi)
            return left + right               

報告錯誤

RecursionError：比較中超出了最大遞歸深度

---

在0.005秒內進行1次測試

這是什么問題？

Answer 4

我正在從leetcode的精選教程Recursion I中學習遞歸基礎知識

第一個練習是反轉字符串Reverse String-LeetCode

編寫一個反轉字符串的函數。 輸入字符串以字符數組char[] 。

不要為另一個數組分配額外的空間，必須通過使用O（1）額外的內存就地修改輸入數組來做到這一點。

您可以假定所有字符都由可打印的ascii字符組成。

范例1：

 Input: ["h","e","l","l","o"] Output: ["o","l","l","e","h"]

范例2：

 Input: ["H","a","n","n","a","h"] Output: ["h","a","n","n","a","H"]

公認的解決方案是

class Solution:
    def reverseString(self, s):
        """
        :type s: str
        :rtype: str
        """
        #base case
        if len(s) <= 1:
            return s
        #recur case 
        elif len(s) >= 2:
            n=len(s)
            return self.reverseString(s[n//2:])+self.reverseString(s[:n//2])

解決方案的兩個問題：

1，不能就地修改

2，遞歸切片字符串很昂貴。

作為改進的第一步，引入了參數lo和hi來存儲索引

class Solution:
    def reverseString(self, s, lo=0, hi=None):
        """
        :type s: str
        :rtype: None
        """
        if hi == None:
            hi = len(s)
      #base case
        if hi <= 1:
            return s

        #recur case 
        elif hi >= 2:
            mid = hi // 2
            left = self.reverseString(s, lo, mid)
            right = self.reverseString(s, mid, hi)
            return left + right               

報告錯誤

RecursionError：比較中超出了最大遞歸深度

---

在0.005秒內進行1次測試

這是什么問題？

Answer 5

這是一個就地遞歸算法。 就地基本上意味着不使用任何輔助數據結構。 請記住，我們總是在內部使用堆棧來執行遞歸。 基本情況：如果 left >= right，則什么都不做。 否則：交換 s[left] 和 s[right] 並調用 helper(left + 1, right - 1)。

為了解決這個問題，調用 helper 函數，將頭和尾索引作為參數傳遞：return helper(0, len(s) - 1)。

def reverseString(s):
    def helper(left, right):
        if left < right:
            s[left], s[right] = s[right], s[left]
            helper(left + 1, right - 1)
    helper(0, len(s) - 1)

時間復雜度 - O(n)

輔助空間 - O(n)

Answer 6

這是我的解決方案。 兩指針方法和二分查找

s = ["h","e","l","l","o"]
print(s)
start = 0
end = len(s)-1
while start <= end:
    temp = s[start]
    s[start] = s[end]
    s[end] = temp
    start += 1
    end -= 1
print((s))

Answer 7

這是我在 cpp 中的代碼。 我已經使用遞歸解決了這個問題，但不知道這是多少有效的解決方案？ BTW 下面的代碼被接受。

void recursive(int start, int end, vector<char>& s) {
    
    if(start >= s.size()/2) {
        
        return;
    }
    recursive(start+1, end-1, s);
    swap(s[start], s[end]);
}


void reverseString(vector<char>& s) {
    
    int size = s.size();
    recursive(0, size-1, s);
}