C Program to Reverse a String Using Recursion

A school text exercise needs to recursive string reversal while preserving the buffer’s valid characters and final terminator.

Print a terminated string in reverse by decreasing a known length, stopping before any access when that length is zero.

Before this exercise, review strings and their terminator and array bounds. The worked program below applies those ideas to this specific problem.

Explain
Explain why recursive string reversal uses this sequence of operations.
Trace
Trace the sample values and predict the printed result.
Apply
Reverse Ravi with the same helper and verify that its zero-length base case performs no access.

Recursive String Reversal: follow the data

Given data
A school text exercise needs to recursive string reversal while preserving the buffer’s valid characters and final terminator.
Rule
Print a terminated string in reverse by decreasing a known length, stopping before any access when that length is zero.
Observed result
ahsA

A guided model of this example. The illustration explains the process; run the complete C program to check its output.

Understand the operation

The helper prints the last valid byte and then recurses on the prefix. It reverses character order, including spaces, rather than reversing only the order of complete words.

A C string ends at its first null character. Read only within its accessible storage and reserve a position for that terminator when producing a changed string. These examples use basic text bytes, not a Unicode grapheme-processing library.

Read the complete C program

The input values are written into this complete C17 example so the calculation can be reproduced without an unavailable service. Change the named data, rebuild and compare the actual output with your prediction.

C17 · complete program

#include <stdio.h>
#include <string.h>
#include <ctype.h>
static void print_reverse(const char *text, size_t length) {
  if (length == 0) return;
  putchar((unsigned char)text[length - 1]);
  print_reverse(text, length - 1);
}
int main(void) {
  const char text[] = "Asha";
  print_reverse(text, strlen(text));
  putchar('\n');
  return 0;
}

Expected output

ahsA

Run in C compiler →

Follow the values through the code

C17 · code used in this explanation

#include <stdio.h>
#include <string.h>
#include <ctype.h>
static void print_reverse(const char *text, size_t length) {
  if (length == 0) return;
  putchar((unsigned char)text[length - 1]);
  print_reverse(text, length - 1);
}
int main(void) {
  const char text[] = "Asha";
  print_reverse(text, strlen(text));
  putchar('\n');
  return 0;
}

The first printed character is a; the next call uses a prefix one character shorter.

Compare the printed answer with the original text and the stated ordering or filtering rule. The presence of a terminator makes %s usable; it does not by itself make every earlier write fit.

Follow the worked calculation

Start with the sample
The first printed character is a; the next call uses a prefix one character shorter.
Apply the rule
Compare the printed answer with the original text and the stated ordering or filtering rule. The presence of a terminator makes %s usable; it does not by itself make every earlier write fit.
3
Check the result
ahsA
```
ahsA
```

A guided model of this example. The illustration explains the process; run the complete C program to check its output.

Try a small variation

C17 · code used in this explanation

#include <stdio.h>
#include <string.h>
#include <ctype.h>
static void print_reverse(const char *text, size_t length) {
  if (length == 0) return;
  putchar((unsigned char)text[length - 1]);
  print_reverse(text, length - 1);
}
int main(void) {
  const char text[] = "Asha";
  print_reverse(text, strlen(text));
  putchar('\n');
  return 0;
}

Reverse Ravi with the same helper and verify that its zero-length base case performs no access.

Worked answer

The complete worked answer applies the same explicitly bounded operation to a small variation. Read its stored bytes and terminator separately from the visible output.

C17 · complete program

#include <stdio.h>
#include <string.h>
#include <ctype.h>
static void print_reverse(const char *text, size_t length) {
  if (length == 0) return;
  putchar((unsigned char)text[length - 1]);
  print_reverse(text, length - 1);
}
int main(void) {
  const char text[] = "Ravi";
  print_reverse(text, strlen(text));
  putchar('\n');
  return 0;
}

Expected output

ivaR

Run in C compiler →

Recognize the important boundaries

Recursion depth grows with byte length. Use an iterative approach for long text; a byte reversal can also break a multibyte encoding.

An untrusted input string needs a verified buffer bound and a valid terminator. strlen is not a safe way to prove arbitrary raw storage has a terminator.

Choose the answer, then compare the reasoning for every option.

Use the idea independently

Print a terminated string in reverse by decreasing a known length, stopping before any access when that length is zero.

Continue with character-array storage.

Continue with bounded line reading.

Language reference: WG14 C11 committee draft. These examples use the C17-compatible subset of the explained language features.

Reaching the recap and completing the quizzes are separate milestones.

Next lesson: C Program to Reverse a Sentence Using Recursion →

C Program to Reverse a String Using Recursion