reversing an array of characters without creating a new array

Question

How can I reverse an array in place (without creating a new array)?

Answer 1

public static int[] reverseArrayWithoutTempArray(int[] array) {
    int i = 0, j = array.length - 1;
    for (i = 0; i < array.length / 2; i++, j--) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
    return array;
}

Answer 2

Homework means pseudo-code only from me, which you've made relatively easy by not specifying what language you want anyway :-)

Turn this into your language of choice:

Set i1 to index of first element in array
Set i2 to index of last element in array
while i1 < i2:
    Set temporary variable to element number i1
    Set element number i1 to element number i2
    Set element number i2 to temporary value
    Add 1 to i1
    Subtract 1 from i2

An ideal thing to do is to actually run that algorithm in your head, using a piece of paper to keep track of variables:

• each the elements in the array.
• i1 and i2.
• temporary variable.

I tend to do that for simpler algorithms. Harder ones I insert debug statement into so that the computer can do that grunt work for me. Start with a piece of paper thus:

i1 | i2 | tempvar | el[0] | el[1] | el[2] | el[3] | el[4] | el[5]
---+----+---------+-------+-------+-------+-------+-------+------
                      H       e       l       l       o       !

and just run through the steps one by one, checking and/or changing each column as you go. That will result in you understanding how it works far better than just being given some code.

Answer 3

Reverse an array of characters without creating a new array using java.

import java.util.*;


//Reverse string array
public static void reverseArray(String[] array){

    int middle = array.length / 2;

    String temp;
    int j = array.length -1;

    for (int i = 0 ; i < middle; i++) {
        temp = array[i];
        array[i] = array[j];
        array[j] = temp;
        j--;
    }

    System.out.println(Arrays.toString(array));
}

If you want to reverse int array, you have to change public static void reverseArray(String[] array) as public static void reverseArray(int[] array) and String temp as int temp.

Example:

public static void main (String[] args) throws java.lang.Exception{
      String[] array = {"Smith", "Peter", "Michel", "John"};
      reverseArray(array);
}

Output :

[John, Michel, Peter, Smith]

Answer 4

Swap the ends constantly, using a single variable as a temporary buffer. In pseudo-code:

temp = a[0]
a[0] = a[size - 1]
a[size - 1] = temp

and so on.

Answer 5

public static void main(String args[]){
            int j=arr.length;       
for(int i=0;i<arr.length/2;i++){
            int temp=arr[i];
            arr[i]=arr[j-1-i];
            arr[j-1-i]=temp;}
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }

Answer 6

reversing an array of characters without creating a new array

public static void main(String[] args) {
    char[] a = {'1', '2', '3','4'};
    char temp = ' ';
    for (int i = 0; i < a.length / 2; i++) {
        temp = a[i];
        a[i] = a[a.length - 1 - i];
        a[a.length - 1 - i] = temp;
    }
    System.out.println(a);
}

Answer 7

Dont bother reversing the array in memory, just iterate over it backwards!

Answer 8

Here is the solution to reverse an array elements without using temp variable or another array. This will work only Java 8 and above version.

void invertUsingStreams(Object[] arr2) {
    IntStream.rangeClosed(1,arr2.length)
       .mapToObj(i -> arr2[arr2.length-i])
       .forEach(System.out::println);
}

Thanks,

Answer 9

Here is a complete program, just copy paste and run it in your IDE :

public class ReverseArrayWithoutAnotherArray {

public static void main(String[] args) {

    int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

    int middle = array.length / 2;

    int temp;
    int j = array.length -1;

    for(int a : array){
        System.out.println(" before reverse :: " + a);
    }
    for (int i = 0 ; i < middle; i++, j--) {
        temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    for(int a : array){
        System.out.println(" after reverse :: " + a);
    }
}
}

output :

 before reverse :: 1
 before reverse :: 2
 before reverse :: 3
 before reverse :: 4
 before reverse :: 5
 before reverse :: 6
 before reverse :: 7
 before reverse :: 8
 before reverse :: 9
 before reverse :: 10
 after reverse :: 10
 after reverse :: 9
 after reverse :: 8
 after reverse :: 7
 after reverse :: 6
 after reverse :: 5
 after reverse :: 4
 after reverse :: 3
 after reverse :: 2
 after reverse :: 1

Answer 10

Array.prototype.reverse = function() {
  for(var i = 0, j = this.length-1; i < j; i++, j--) {
    var tmp = this[i];
    this[i] = this[j];
    this[j] = tmp;
  }
  return this;
};

Answer 11

• Use temp variables to temporary hold the variables
• use two index pointer, one is from first index and last from array length
• iterate the array till the middle of the array elements
• Below is the function i created to do the same
• it works for both even and odd size
• Input Array 1 4 3 2
• Expected Out 2 3 4 1

static int[] reverseArray(int[] a) {

    int j=a.length-1; // last index pointer

    int middle = a.length/2; // end condition

    for (int i=0;i<middle;i++){
        int temp=a[i];
        a[i]=a[j];
        a[j]=temp;
        j--;
    }

    return a;

}

Answer 12

var arr = [1,2,3,4,5,6]
for(let i=arr.length-2;i>=0;i--){
   arr.push(arr.splice(i,1)[0])
}
console.log(arr) // [6,5,4,3,2,1]

var arr2 = [1,2,3,4,5,6]
for(let i=0,j=arr2.length-1;i<arr2.length/2;i++){
   let temp = arr2[i];
   arr2[i] = arr2[j-i];
   arr2[j-i] = temp
}
console.log(arr2) // [6,5,4,3,2,1]

Answer 13

import java.util.Scanner;
import java.util.Arrays;

public class reversearray {
    private static Scanner scanner=new Scanner(System.in);

    public static void main(String[] args) {
        System.out.println("enter the count value ");
        int n=scanner.nextInt();
        int[] value=new int[n];
        System.out.println("enter the elements of an array");
        for(int i=0;i<n;i++)
        {
            value[i]=scanner.nextInt();
        }
        reverse(value);

    }
    public static void reverse(int[] array) {
        int n = array.length - 1;
        int temp = 0;
        int count=0;
        boolean swapped = true;
        int mid = n / 2;

        for (int i = 0; i < mid; i++) {
            temp = array[i];
            array[i] = array[n - i];
            array[n - i] = temp;
            count++;
        }
        if(count==(n-mid))
        {
            array[mid]=array[mid];
        }
        else
        {
            temp=array[mid];
            array[mid]=array[mid+1];
            array[mid+1]=temp;
        }

        System.out.println("the reveresed array elements are: " + Arrays.toString(array));
    }
}