Algocademy Logo

Course Outline

Reverse String III in Python with O(n) Time Complexity


Given a string, write a function that reverses that string without using built-in functions or libraries.

Example:

Input:  "hello"

Output: "olleh"

Note:

Your algorithm should run in O(n) time and use O(n) extra space.


Problem Definition

The task is to reverse a given string without using any built-in functions or libraries. The input is a single string, and the output should be the reversed version of that string.

Input:

  • A single string s.

Output:

  • A single string which is the reverse of s.

Constraints:

  • The algorithm should run in O(n) time complexity.
  • The algorithm should use O(n) extra space.

Example:

Input: "hello"
Output: "olleh"

Understanding the Problem

The core challenge is to reverse the string efficiently without using built-in functions. This problem is significant in various applications such as data processing, text manipulation, and algorithms that require string transformations.

Potential pitfalls include misunderstanding the constraints and attempting to use built-in functions which are not allowed.

Approach

To solve this problem, we need to think about how to reverse a string manually. A naive solution might involve iterating through the string from the end to the beginning and constructing a new string. However, this approach is not optimal in terms of space complexity.

Naive Solution:

Iterate through the string from the end to the beginning and append each character to a new string. This approach is straightforward but not optimal because it involves creating a new string in each iteration, leading to O(n^2) time complexity.

Optimized Solution:

We can use a list to store the characters of the string in reverse order and then join them to form the reversed string. This approach ensures O(n) time complexity and O(n) space complexity.

Thought Process:

  • Initialize an empty list to store the characters in reverse order.
  • Iterate through the string from the end to the beginning and append each character to the list.
  • Join the list to form the reversed string.

Algorithm

Here is a step-by-step breakdown of the optimized algorithm:

  1. Initialize an empty list reversed_chars.
  2. Iterate through the string from the last character to the first character.
  3. Append each character to reversed_chars.
  4. Join the list reversed_chars to form the reversed string.

Code Implementation

def reverse_string(s):
    # Initialize an empty list to store the reversed characters
    reversed_chars = []
    
    # Iterate through the string from the end to the beginning
    for i in range(len(s) - 1, -1, -1):
        # Append each character to the list
        reversed_chars.append(s[i])
    
    # Join the list to form the reversed string
    reversed_string = ''.join(reversed_chars)
    
    return reversed_string

# Example usage
input_string = "hello"
output_string = reverse_string(input_string)
print(output_string)  # Output: "olleh"

Complexity Analysis

The time complexity of the optimized solution is O(n) because we iterate through the string once. The space complexity is O(n) because we use a list to store the characters of the string.

Comparison:

  • Naive Solution: O(n^2) time complexity, O(n) space complexity.
  • Optimized Solution: O(n) time complexity, O(n) space complexity.

Edge Cases

Consider the following edge cases:

  • Empty string: The output should be an empty string.
  • Single character string: The output should be the same as the input.
  • String with spaces: The spaces should be reversed along with the characters.

Examples:

Input: ""
Output: ""

Input: "a"
Output: "a"

Input: "a b c"
Output: "c b a"

Testing

To test the solution comprehensively, consider a variety of test cases:

  • Simple strings
  • Strings with spaces
  • Strings with special characters
  • Edge cases such as empty strings and single character strings

Example Test Cases:

def test_reverse_string():
    assert reverse_string("") == ""
    assert reverse_string("a") == "a"
    assert reverse_string("hello") == "olleh"
    assert reverse_string("a b c") == "c b a"
    assert reverse_string("12345") == "54321"
    print("All test cases pass")

test_reverse_string()

Thinking and Problem-Solving Tips

When approaching such problems, consider the following tips:

  • Understand the problem constraints and requirements.
  • Think about the most efficient way to solve the problem.
  • Break down the problem into smaller, manageable parts.
  • Consider edge cases and how to handle them.
  • Practice solving similar problems to improve problem-solving skills.

Conclusion

In this blog post, we discussed how to reverse a string without using built-in functions or libraries. We explored a naive solution and an optimized solution, analyzed their complexities, and provided a detailed code implementation. Understanding and solving such problems is crucial for improving algorithmic thinking and coding skills.

Additional Resources

For further reading and practice, consider the following resources: