使用递归就地反转字符串

Question

There is a leetcode question on recursion. Reverse a string, in place, using recursion. Do not allocate an additional array.

Write a function that reverses a string. The input string is given as an array of characters char[].

Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.

You may assume all the characters consist of printable ASCII characters.

My solution doesn't work as my slicing operator is creating a copy of the list, rather than being in place. I can't seem to add a parameter to the function, as the test harness isn't expecting an additional parameter.

How do you do this, without an additional parameter to detect the current position index into the string you are trying to reverse, or without an intermediate data structure you append to through the recursive call?

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        
        if len(s) <= 1:
            return
        
        temp = s[0]
        s[0] = s[len(s)-1]
        s[len(s)-1] = temp        
        return self.reverseString(s[1:len(s)-1])
        

My function with an input of "hello" returns ["o","e","l","l","h"] . This is because the first time the function is called it operates on the list in place, and subsequent calls are achieved through a slice of the string.

Answer 1

Thanks all. The solution was to add a parameter with a default, to get over the issues with the leetcode test harness, so now I can do it as below:

   class Solution:
    def reverseString(self, s: List[str], start = 0) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        if len(s[start:len(s)-start]) <= 1:
            return
        
        end = len(s) - start - 1 # end postition
        
        temp = s[start]        
        s[start] = s[end]        
        s[end] = temp
        
        self.reverseString(s, start+1)
        
        

Answer 2

Try this

chars=list('string')
for i in range((len(chars)-len(chars)%2)//2):
    chars[i], chars[-i-1]=chars[-i-1], chars[i]
print(chars)
print(''.join(chars))

Answer 3

From what i understood, the solution should be recursive. Try this:

EDIT: (as should look in leetcode)

def reverseStringHelper(s, index):
    length = len(s)
    if index >= length / 2:
        return
    
    temp = s[index]
    s[index] = s[length - 1 - index]
    s[length - 1 - index] = temp
    reverseString(s, index + 1)

def reverseString(s):
    reverseStringHelper(s, 0)

Defining arr = ['h', 'e', 'l', 'l','o'] and calling reverseString(arr, 0) will result in ['o', 'l', 'l', 'e', 'h']

You may call it from a different function so it would only accept the list.

Answer 4

This'll pass, since it has to be done in-place :

from typing import List

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """

        left, right = 0, len(s) - 1
        while left < right:
            s[left], s[right] = s[right], s[left]
            left, right = left + 1, right - 1

---

References

• For additional details, please see the Discussion Board where you can find plenty of well-explained accepted solutions with a variety of languages including low-complexity algorithms and asymptotic runtime / memory analysis ^{1 , 2} .