Reverse an Array in Java

In this tutorial, we will discuss how one can reverse an array in Java. In the input, an integer array is given, and the task is to reverse the input array. Reversing an array means the last element of the input array should be the first element of the reversed array, the second last element of the input array should be the second element of the reversed array, and so on. Observe the following examples.

Example 1:

Input:

arr[] = {1, 2, 3, 4, 5, 6, 7, 8}

Output

arr[] = {8, 7, 6, 5, 4, 3, 2, 1}

Example 2:

Input:

arr[] = {4, 8, 3, 9, 0, 1}

Output:

arr[] = {1, 0, 9, 3, 8, 4}

Approach 1: Using an auxiliary array

We can traverse the array from end to beginning, i.e., in reverse order, and store the element pointed by the loop index in the auxiliary array. The auxiliary array now contains the elements of the input array in reversed order. After that, we can display the auxiliary array on the console. See the following program.

FileName: ReverseArr.java

public class ReverseArr
{
// method for reversing an array
public int[]  reverseArray(int arr[])
{
    // computing the size of the array arr
    int size = arr.length;
    
    // auxiliary array for reversing the 
    // elements of the array arr
    int temp[] = new int[size];
    
    int index = 0;
    for(int i = size - 1; i >= 0; i--)
    {
        temp[i] = arr[index];
        index = index + 1;
    }
    
    return temp;
    
}

// main method
public static void main(String argvs[]) 
{
  // creating an object of the class ReverseArr
  ReverseArr obj = new ReverseArr();
  
  // input array - 1
  int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
  
  // computing the length
  int len = arr.length;
  int ans[] = obj.reverseArray(arr);
  
  System.out.println("For the input array: ");
  for(int  i = 0; i < len; i++)
  {
     System.out.print(arr[i] + " ");
  }
  
  System.out.println();
  System.out.println("The reversed array is: ");
  for(int  i = 0; i < len; i++)
  {
     System.out.print(ans[i] + " ");
  }
  
  System.out.println("\n ");
  
  // input array - 2
  int arr1[] = {4, 8, 3, 9, 0, 1};
  
  // computing the length
  len = arr1.length;
  int ans1[] = obj.reverseArray(arr1);
  
  System.out.println("For the input array: ");
  for(int  i = 0; i < len; i++)
  {
     System.out.print(arr1[i] + " ");
  }
  
  System.out.println();
  System.out.println("The reversed array is: ");
  for(int  i = 0; i < len; i++)
  {
     System.out.print(ans1[i] + " ");
  }
      
 
}
}

Output:

For the input array: 
1 2 3 4 5 6 7 8 
The reversed array is: 
8 7 6 5 4 3 2 1 
 
For the input array: 
4 8 3 9 0 1 
The reversed array is: 
1 0 9 3 8 4

Complexity Analysis: A for loop is required to reverse the array, which makes the time complexity of the program O(n). Also, an auxiliary array is required to reverse the array making the space complexity of the program O(n), where n is the total number of elements present in the array.

Approach 2: Using Two Pointers

We can also use two pointers to reverse the input array. The first pointer will go to the first element of the array. The second pointer will point to the last element of the input array. Now we will start swapping elements pointed by these two pointers. After swapping, the second pointer will move in the leftward direction, and the first pointer will move in the rightward direction. When these two pointers meet or cross each other, we stop the swapping, and the array we get is the reversed array of the input array.

FileName: ReverseArr1.java

public class ReverseArr1
{
// method for reversing an array
public int[]  reverseArray(int arr[])
{
    // computing the size of the array arr
    int size = arr.length;
    
    // two pointers for reversing 
    // the input array
    int ptr1 = 0;
    int ptr2 = size - 1;
    
    // reversing the input array
    // using a while loop
    while(ptr1 < ptr2)
    {
        int temp = arr[ptr1];
        arr[ptr1] = arr[ptr2];
        arr[ptr2] = temp;
        
        ptr1 = ptr1 + 1;
        ptr2 = ptr2 - 1;
    }
    
    return arr;
    
}

// main method
public static void main(String argvs[]) 
{
  // creating an object of the class ReverseArr1
  ReverseArr1 obj = new ReverseArr1();
  
  // input array - 1
  int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
  
  // computing the length
  int len = arr.length;
  
  
  System.out.println("For the input array: ");
  for(int  i = 0; i < len; i++)
  {
     System.out.print(arr[i] + " ");
  }
  
  int ans[] = obj.reverseArray(arr);
  
  System.out.println();
  System.out.println("The reversed array is: ");
  for(int  i = 0; i < len; i++)
  {
     System.out.print(ans[i] + " ");
  }
  
  System.out.println("\n ");
  
  // input array - 2
  int arr1[] = {4, 8, 3, 9, 0, 1};
  
  // computing the length
  len = arr1.length;
  
  
  System.out.println("For the input array: ");
  for(int  i = 0; i < len; i++)
  {
     System.out.print(arr1[i] + " ");
  }
  
  int ans1[] = obj.reverseArray(arr1);
  
  System.out.println();
  System.out.println("The reversed array is: ");
  for(int  i = 0; i < len; i++)
  {
     System.out.print(ans1[i] + " ");
  }
      
 
}
}

Output:

For the input array: 
1 2 3 4 5 6 7 8 
The reversed array is: 
8 7 6 5 4 3 2 1 
 
For the input array: 
4 8 3 9 0 1 
The reversed array is: 
1 0 9 3 8 4

Complexity Analysis: The time complexity of the program is the same as the previous program. There is no extra space used in the program, making the space complexity of the program O(1).

Approach 3: Using Stack

Since a Stack works on the LIFO (Last In First Out) principle, it can be used to reverse the input array. All we have to do is to put all the elements of the input array in the stack, starting from left to right. We will do it using a loop.

FileName: ReverseArr2.java

// importing Stack
import java.util.Stack;


public class ReverseArr2
{
// method for reversing an array
public int[]  reverseArray(int arr[])
{
    // computing the size of the array arr
    int size = arr.length;
    
    Stack<Integer> stk = new Stack<Integer>();
    
    // pusing all the elements into stack
    // starting from left
    for(int i = 0; i < size; i++)
    {
        stk.push(arr[i]);
    }
    
    int i = 0;
    while(!stk.isEmpty())
    {
        int ele = stk.pop();
        arr[i] = ele;
        i = i + 1;
    }
    
    return arr;
    
}

// main method
public static void main(String argvs[]) 
{
  // creating an object of the class ReverseArr2
  ReverseArr2 obj = new ReverseArr2();
  
  // input array - 1
  int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
  
  // computing the length
  int len = arr.length;
  
  
  System.out.println("For the input array: ");
  for(int  i = 0; i < len; i++)
  {
     System.out.print(arr[i] + " ");
  }
  
  int ans[] = obj.reverseArray(arr);
  
  System.out.println();
  System.out.println("The reversed array is: ");
  for(int  i = 0; i < len; i++)
  {
     System.out.print(ans[i] + " ");
  }
  
  System.out.println("\n ");
  
  // input array - 2
  int arr1[] = {4, 8, 3, 9, 0, 1};
  
  // computing the length
  len = arr1.length;
  
  
  System.out.println("For the input array: ");
  for(int  i = 0; i < len; i++)
  {
     System.out.print(arr1[i] + " ");
  }
  
  int ans1[] = obj.reverseArray(arr1);
  
  System.out.println();
  System.out.println("The reversed array is: ");
  for(int  i = 0; i < len; i++)
  {
     System.out.print(ans1[i] + " ");
  }
      
 
}
}

Output:

For the input array: 
1 2 3 4 5 6 7 8 
The reversed array is: 
8 7 6 5 4 3 2 1 
 
For the input array: 
4 8 3 9 0 1 
The reversed array is: 
1 0 9 3 8 4

Complexity Analysis: The time complexity of the program is the same as the previous program. There is stack used in the program, making the space complexity of the program O(n).

Using Recursion

Using recursion also, we can achieve the same result. Observe the following.

FileName: ReverseArr3.java

// importing ArrayList
import java.util.ArrayList;


public class ReverseArr3
{
ArrayList<Integer> reverseArr;

// constructor of the class
ReverseArr3()
{
reverseArr = new  ArrayList<Integer>();
}

// method for reversing an array
public void  reverseArray(int arr[], int i, int size)
{
// dealing with the base case
if(i >= size)
{
    return;
}

// recursively calling the method
reverseArray(arr, i + 1, size);
reverseArr.add(arr[i]);
    
}

// main method
public static void main(String argvs[]) 
{
  // creating an object of the class ReverseArr3
  ReverseArr3 obj = new ReverseArr3();
  
  // input array - 1
  int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
  
  // computing the length
  int len = arr.length;
  
  
  System.out.println("For the input array: ");
  for(int  i = 0; i < len; i++)
  {
     System.out.print(arr[i] + " ");
  }
  
  obj.reverseArray(arr, 0 , len);
  
  System.out.println();
  System.out.println("The reversed array is: ");
  for(int  i = 0; i < len; i++)
  {
     System.out.print(obj.reverseArr.get(i) + " ");
  }
  
  System.out.println("\n ");
  
  obj = new ReverseArr3();
  
  // input array - 2
  int arr1[] = {4, 8, 3, 9, 0, 1};
  
  // computing the length
  len = arr1.length;
  
  
  System.out.println("For the input array: ");
  for(int  i = 0; i < len; i++)
  {
     System.out.print(arr1[i] + " ");
  }
  
  obj.reverseArray(arr1, 0, len);
  
  System.out.println();
  System.out.println("The reversed array is: ");
  for(int  i = 0; i < len; i++)
  {
      System.out.print(obj.reverseArr.get(i) + " ");
  }
      
 
}
}

Output:

For the input array: 
1 2 3 4 5 6 7 8 
The reversed array is: 
8 7 6 5 4 3 2 1 
 
For the input array: 
4 8 3 9 0 1 
The reversed array is: 
1 0 9 3 8 4

Explanation: The statement reverseArr.add(arr[i]); is written after the recursive call goes in the stack (note that the stack is implicit in this case). So, when the base case is hit in the recursive call, stack unwinding happens, and whatever is there in the stack pops out. The last element goes into the stack during the last recursive call. Therefore, the last element is popped out first. Then the penultimate element is popped out, and so on. The statement reverseArr.add(arr[i]); stores that popped element. In the end, we are displaying the elements that are stored in the list reverseArr.

Complexity Analysis: Same as the first program of approach-3.

Approach 4: Using Collections.reverse() method

The build method Collections.reverse() can be used to reverse the list. The use of it is shown in the following program.

FileName: ReverseArr4.java

// importing Collections, Arrays, ArrayList & List
import java.util.Collections;
import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;

public class ReverseArr4
{

// method for reversing an array
public List<Integer>  reverseArray(Integer arr[])
{
List<Integer> l = (Arrays.asList(arr));
Collections.reverse(l);
return l;
}

// main method
public static void main(String argvs[]) 
{
  // creating an object of the class ReverseArr4
  ReverseArr4 obj = new ReverseArr4();
  
  // input array - 1
  Integer arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
  
  // computing the length
  int len = arr.length;
  
  
  System.out.println("For the input array: ");
  for(int  i = 0; i < len; i++)
  {
     System.out.print(arr[i] + " ");
  }
  
  List<Integer> ans = obj.reverseArray(arr);
  
  System.out.println();
  System.out.println("The reversed array is: ");
  for(int  i = 0; i < len; i++)
  {
     System.out.print(ans.get(i) + " ");
  }
  
  System.out.println("\n ");

  // input array - 2
  Integer arr1[] = {4, 8, 3, 9, 0, 1};
  
  // computing the length
  len = arr1.length;
  
  
  System.out.println("For the input array: ");
  for(int  i = 0; i < len; i++)
  {
     System.out.print(arr1[i] + " ");
  }
  
  ans = obj.reverseArray(arr1);
  
  System.out.println();
  System.out.println("The reversed array is: ");
  for(int  i = 0; i < len; i++)
  {
      System.out.print(ans.get(i) + " ");
  }
      
 
}
}

Output:

For the input array: 
1 2 3 4 5 6 7 8 
The reversed array is: 
8 7 6 5 4 3 2 1 
 
For the input array: 
4 8 3 9 0 1 
The reversed array is: 
1 0 9 3 8 4

Complexity Analysis: The program uses Collections.reverse() method that reverses the list in linear time, making the time complexity of the program O(n). The program uses using list, making the space complexity of the program O(n), where n is the total number of elements present in the array.

Note 1: Collections.reverse() method is also used to reverse the linked list.

Note 2: All the approaches discussed above are applicable to different data types too.

Approach 5: Using StringBuilder.append() method

It is evident from the heading that this approach is applicable to string arrays. Using the StringBuilder.append() method, we can reverse the string array. All we have to do is to start appending the string elements of the array from the last to the beginning.

FileName: ReverseArr5.java

import java.util.*;

public class ReverseArr5
{

// method for reversing an array
public String[]  reverseArray(String arr[])
{
StringBuilder reversedSB = new StringBuilder();

for (int j = arr.length; j > 0; j--) 
{
  reversedSB.append(arr[j - 1]).append(" ");
};

String[] reversedArr = reversedSB.toString().split(" ");
return reversedArr;
}

// main method
public static void main(String argvs[]) 
{
  // creating an object of the class ReverseArr5
  ReverseArr5 obj = new ReverseArr5();
  
  // input array - 1
  String arr[] = {"javaTpoint", "is", "the", "best", "website"};
  
  // computing the length
  int len = arr.length;
  
  
  System.out.println("For the input array: ");
  for(int  i = 0; i < len; i++)
  {
     System.out.print(arr[i] + " ");
  }
  
  String[] ans = obj.reverseArray(arr);
  
  System.out.println();
  System.out.println("The reversed array is: ");
  for(int  i = 0; i < len; i++)
  {
     System.out.print(ans[i] + " ");
  }
  
  System.out.println("\n ");

  // input array - 2
  String arr1[] = {"India", "is", "my", "country"};
  
  // computing the length
  len = arr1.length;
  
  
  System.out.println("For the input array: ");
  for(int  i = 0; i < len; i++)
  {
     System.out.print(arr1[i] + " ");
  }
  
  String[] ans1 = obj.reverseArray(arr1);
  
  System.out.println();
  System.out.println("The reversed array is: ");
  for(int  i = 0; i < len; i++)
  {
      System.out.print(ans1[i] + " ");
  }
      
 
}
}

Output:

For the input array: 
javaTpoint is the best website 
The reversed array is: 
website best the is javaTpoint 
 
For the input array: 
India is my country 
The reversed array is: 
country my is India

Complexity Analysis: The time and space complexity of the program is the same as the previous program.

Next TopicRight Shift Zero Fill Operator in Java

← prev next →