Reverse array using recursion
Reversing an array is a common task in computer programming. In this article, we will explore how to reverse an array using recursion. Recursion is a programming technique where a function calls itself to solve a smaller instance of the same problem.
Introduction
The problem we are trying to solve is to reverse the elements of a given array. For example, if we have an array [1, 2, 7, 3, 4, 5, 8, 9], after reversing it, the array will be [9, 8, 5, 4, 3, 7, 2, 1]. To achieve this, we will use a recursive function.
Problem Statement
Given an array of integers, we need to reverse the order of its elements using a recursive approach. The recursive function should take the array and the indices of the front and tail elements as input parameters and reverse the elements between these indices.
Example
Let's understand the process with a suitable example. Consider the array [1, 2, 3, 4, 5].
 Initial Array: [1, 2, 3, 4, 5]
 Swap elements at the front and tail indices: [5, 2, 3, 4, 1]
 Call the recursive function with front + 1 and tail  1 as new indices: [5, 4, 3, 2, 1]
 Swap elements at the front and tail indices: [5, 4, 3, 2, 1] (unchanged)
 Recursive call with front + 1 and tail  1: [5, 4, 3, 2, 1] (unchanged)
At this point, the front index becomes greater than the tail index, and the recursion stops. The final reversed array is [5, 4, 3, 2, 1].
Pseudocode
Let's represent the algorithm in pseudocode:
function reverse_array(data[], front, tail):
if front < tail:
swap data[front] with data[tail]
reverse_array(data, front + 1, tail  1)
Algorithm Explanation
The recursive function reverse_array
takes three parameters: the array data
and the indices front
and tail
. The base case of the recursion is when the front
index becomes greater than or equal to the tail
index, in which case the function returns without doing anything.
If the base case is not met, the function swaps the elements at indices front
and tail
, effectively reversing the order of the elements between these indices. Then, the function makes a recursive call with front + 1
and tail  1
as the new indices, so the next pair of elements can be swapped, continuing the reversal process.
Program List

1) Reverse array using recursion in c
2) Reverse array using recursion in java
3) Reverse array using recursion in c++
4) Reverse array using recursion in c#
5) Reverse array using recursion in php
6) Reverse array using recursion in python
7) Reverse array using recursion in ruby
8) Reverse array using recursion in scala
9) Reverse array using recursion in node js
10) Reverse array using recursion in swift
11) Reverse array using recursion in vb.net
12) Reverse array using recursion in golang
13) Reverse array using recursion in kotlin
14) Reverse array using recursion in typescript
Time Complexity
The time complexity of the recursive function depends on the number of recursive calls made. For an array of size n
, the function makes n/2
recursive calls, as we halve the problem size in each recursive step. Therefore, the time complexity of the reverse_array
function is O(n
), where n
is the size of the input array.
Output Explanation
Let's analyze the output of the provided C code:
Before Reverse
1 2 7 3 4 5 8 9
After Reverse
9 8 5 4 3 7 2 1
The initial array is [1, 2, 7, 3, 4, 5, 8, 9]. After calling the reverse_array
function, the array is reversed, resulting in [9, 8, 5, 4, 3, 7, 2, 1], which is the expected output.
Finally
In this article, we explored how to reverse an array using recursion. We presented a recursive function that swaps the front and tail elements iteratively until the entire array is reversed. Recursion provides an elegant way to solve this problem, and the time complexity of the algorithm is linear, making it efficient for arrays of moderate size.
Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.
New Comment