Reverse A String In C Without Using Inbuilt Function

In this article, you will learn various methods to reverse a string in C without relying on standard library functions designed specifically for string reversal. We will explore practical, step-by-step solutions suitable for different scenarios.

Problem Statement

Reversing a string involves rearranging its characters such that the last character becomes the first, the second-to-last becomes the second, and so on, until the first character becomes the last. The core challenge is to achieve this transformation using fundamental C programming constructs like loops, arrays, and pointers, without leveraging higher-level string manipulation functions from the standard library (such as strrev). This task is a common interview question and a good exercise for understanding memory manipulation in C.

Example

Consider the input string "hello". The desired output after reversal should be "olleh".

Background & Knowledge Prerequisites

To effectively understand the solutions presented, readers should have a basic grasp of:

• C Language Fundamentals: Variables, data types, control flow (loops like for and while).
• Arrays: How character arrays (strings) are declared and manipulated in C.
• Pointers: Basic understanding of pointer arithmetic and dereferencing.
• Memory Management: A general idea of how data is stored in memory.

For setup, you will only need a C compiler (like GCC) and a text editor.

Use Cases or Case Studies

Reversing a string might seem like a simple academic exercise, but it has several practical applications:

• Palindrome Detection: To check if a string reads the same forwards and backward (e.g., "madam"), reversing the string is a common first step.
• Data Processing: In some data transformation tasks, reversing specific parts of a string might be required before further analysis.
• Encryption Algorithms: Certain simple cryptographic techniques might involve reversing parts of a message or key as part of their encoding or decoding process.
• Text Formatting and Display: For specialized text effects or when displaying text in certain right-to-left contexts, string reversal might be a utility function.
• Algorithm Challenges: It's a foundational problem that helps build intuition for more complex string algorithms and memory manipulation.

Solution Approaches

We will explore two effective methods to reverse a string in C without using inbuilt string reversal functions. First, we'll implement a custom function to determine the length of the string, as strlen is a standard library function.

Custom String Length Function

Before we reverse a string, we often need its length. We can implement a simple function to calculate it manually.

• Summary: Iterates through the string until the null terminator \0 is found, counting characters along the way.
• Code Example:

// Custom String Length Calculation
#include <stdio.h> // Required for printf

// Function to calculate string length manually
int get_string_length(char* str) {
    int length = 0;
    while (str[length] != '\\0') {
        length++;
    }
    return length;
}

int main() {
    char myString[] = "ReverseMe";
    int len = get_string_length(myString);
    printf("Original String: %s\\n", myString);
    printf("Length of string: %d\\n", len);
    return 0;
}

Run

• Sample Output:

Original String: ReverseMe
Length of string: 9

• Stepwise Explanation:

1. The get_string_length function takes a character pointer str as input.
2. An integer length is initialized to 0.
3. A while loop continues as long as the character at the current length index is not the null terminator \0.
4. In each iteration, length is incremented.
5. Once the null terminator is reached, the loop terminates, and the final value of length (which represents the count of characters before \0) is returned.

Approach 1: In-Place Reversal Using Two Pointers

This is one of the most efficient and common methods, as it modifies the string directly without needing extra memory proportional to the string's length.

• Summary: Uses two pointers, one starting at the beginning and the other at the end of the string, swapping characters until they meet in the middle.
• Code Example:

// In-Place String Reversal (Two Pointers)
#include <stdio.h> // Required for printf

// Custom string length function
int get_string_length(char* str) {
    int length = 0;
    while (str[length] != '\\0') {
        length++;
    }
    return length;
}

// Function to reverse a string in-place
void reverse_string_inplace(char* str) {
    int length = get_string_length(str);
    int start = 0;
    int end = length - 1;
    char temp; // Temporary variable for swapping

    while (start < end) {
        // Swap characters at start and end positions
        temp = str[start];
        str[start] = str[end];
        str[end] = temp;

        // Move pointers inward
        start++;
        end--;
    }
}

int main() {
    char myString[] = "programming"; // Modifiable string
    char anotherString[] = "hello world";

    printf("Original string 1: %s\\n", myString);
    reverse_string_inplace(myString);
    printf("Reversed string 1: %s\\n", myString);

    printf("\\nOriginal string 2: %s\\n", anotherString);
    reverse_string_inplace(anotherString);
    printf("Reversed string 2: %s\\n", anotherString);

    return 0;
}

Run

• Sample Output:

Original string 1: programming
Reversed string 1: gnimmargorp

Original string 2: hello world
Reversed string 2: dlrow olleh

• Stepwise Explanation:

1. First, the get_string_length function (defined previously) is called to determine the string's length.
2. Two integer pointers, start and end, are initialized. start points to the first character (index 0), and end points to the last character (index length - 1).
3. A while loop continues as long as start is less than end. This ensures that characters are swapped only once and the middle character (for odd-length strings) remains in place.
4. Inside the loop:
   • The character at str[start] is stored in a temporary variable temp.

1. When start becomes greater than or equal to end, the loop terminates, and the string is fully reversed.

Approach 2: Reversal Using an Auxiliary Array

This method involves creating a temporary array to store the reversed string, then copying it back to the original or using the temporary array as the result.

• Summary: Copies characters from the original string into a new auxiliary array in reverse order, then potentially copies back.
• Code Example:

// String Reversal (Auxiliary Array)
#include <stdio.h> // Required for printf

// Custom string length function
int get_string_length(char* str) {
    int length = 0;
    while (str[length] != '\\0') {
        length++;
    }
    return length;
}

// Function to reverse a string using an auxiliary array
void reverse_string_auxiliary(char* original_str, char* reversed_str) {
    int length = get_string_length(original_str);
    int i, j;

    // Copy characters from original_str to reversed_str in reverse order
    for (i = 0, j = length - 1; i < length; i++, j--) {
        reversed_str[i] = original_str[j];
    }
    reversed_str[length] = '\\0'; // Null-terminate the reversed string
}

int main() {
    char myString[] = "computers";
    char reversed[50]; // Auxiliary array to store the reversed string

    printf("Original string: %s\\n", myString);
    reverse_string_auxiliary(myString, reversed);
    printf("Reversed string: %s\\n", reversed);
    
    char anotherString[] = "data structures";
    char reversed2[50];
    printf("\\nOriginal string: %s\\n", anotherString);
    reverse_string_auxiliary(anotherString, reversed2);
    printf("Reversed string: %s\\n", reversed2);

    return 0;
}

Run

• Sample Output:

Original string: computers
Reversed string: sretupmoc

Original string: data structures
Reversed string: serutcurts atad

• Stepwise Explanation:

1. The get_string_length function is used to determine the length of original_str.
2. A for loop is initialized with two counters: i starting from 0 (for the reversed_str index) and j starting from length - 1 (for the original_str index).
3. The loop continues as long as i is less than length.
4. In each iteration, the character from original_str at index j is copied to reversed_str at index i.
5. i is incremented to move forward in the reversed_str, and j is decremented to move backward in the original_str.
6. After the loop completes, a null terminator \0 is added to the end of reversed_str to ensure it is a valid C string.
7. It's crucial that reversed_str has enough allocated memory to hold the reversed string, including the null terminator.

Conclusion

Reversing a string without built-in functions is a fundamental task that reinforces understanding of C's memory and pointer manipulation. The two-pointer in-place method is generally preferred for its efficiency in terms of memory usage, as it requires only a temporary variable for swapping. The auxiliary array method is simpler to conceptualize but uses additional memory proportional to the string's length. Both approaches are valuable for developing robust C programming skills.

Summary

• Problem: Reverse a string in C without using standard library functions like strrev.
• Custom Length: A custom get_string_length function is essential to avoid using strlen.
• In-Place Reversal (Two Pointers):
• Uses two pointers, start and end, moving inwards from opposite ends of the string.
• Swaps characters at start and end until start crosses or meets end.
• Memory efficient as it modifies the original string directly.
• Auxiliary Array Reversal:
• Creates a temporary array of sufficient size.
• Copies characters from the original string in reverse order into the temporary array.
• Requires additional memory proportional to the string's length.
• Null Termination: Always remember to null-terminate strings, especially when creating new ones or modifying them manually.