Array left rotation in Java

you're rotating only one position at a time, it is very slow, it is better to shift elements to appropriate places, for example:

static int[] rotLeft(int[] a, int d) {
    if (d == 0 || a == null || a.length == 0) {
        return a;
    }

    int[] b = new int[a.length];
    for (int i = 0; i < a.length; i++) {
        b[i] = a[(i + d) % a.length];
    }
    return b;
}

There are two things you could apply to this problem to improve the runtime.

1. Ensure that d is less than a.length. If d is greater than a.length, then you are rotating elements past their original position and wasting cycles. An easy way to achieve this is with the modulus assignment operator (i.e., d %= a.length, which is equivalent to d = d % a.length).

2. Elements should be shifted by the whole distance we are rotating, rather than shifting by one space each time. This allows us to perform the entire operation is 1 action, instead of in d action(s).

Applying these two principles would give us the following code:

static int[] rotLeft(int[] a, int d) {
  if (d < 0) {
    d = a.length - (-d % a.length);
  }

  d %= a.length;

  if (d == 0) {
    return a;
  }

  int first = a[0];

  int i = 0;
  int position = 0;

  while (i < a.length) {
    a[position] = a[(position + d) % a.length];

    position = (position + d) % a.length;
    i++;
  }

  a[a.length - d] = first;

  return a;
}

You make multiple passes, each time rotating by one place, which makes your program slow. There are at least 3 approaches to improve your program:

• allocate a new array and put elements in appropriate locations, instead of rotating in place
• use a buffer to store d elements while rotating others in place
• use a juggling algorithm https://www.google.com/amp/s/www.geeksforgeeks.org/array-rotation/amp/

The third option performs rotation in place.

It may be worthwhile to microbenchmark all 3 to compare the speed for different input sizes

Of course you can repeat the rotation d times as you did in your sample code. But much faster would be if you would calculate the shift and do it in one go:

import static java.lang.System.*;

static int[] rotLeft( int[] a, int d ) 
{
    var len = a.length;
    var shift = d % len;
    var buffer = new int[len]; 
    arraycopy( a, shift, buffer, 0, len - shift );
    arraycopy( a, 0, buffer, len - shift, shift );
    arraycopy( buffer, 0, a, 0, len );
    return a;
}

Of course, instead of System.arraycopy() you can use a for-loop. If you are not forced to return a, you can omit the third call to arraycopy() and return buffer instead; this would leave the original array unchanged, too.

To output the array, try this:

var joiner = new StringJoiner( " " );
for( var v : a ) joiner.add( Integer.toString( v ) );
System.out.println( joiner.toString() );

For better performance, you should use the built-in array copy methods.

If you have to update the existing array, like your code is doing, I'd recommend doing it like this:

static int[] rotLeft(int[] a, int d) {
    if (a == null || a.length <= 1)
        return a; // nothing to rotate
    int shift = (d % a.length + a.length) % a.length; // normalize d
    if (shift == 0)
        return a; // no or full rotation(s)
    int[] t = Arrays.copyOfRange(a, 0, shift);
    System.arraycopy(a, shift, a, 0, a.length - shift);
    System.arraycopy(t, 0, a, a.length - shift, shift);
    return a;
}

If the returned array must be different, like this other answers do, I'd do it like this:

static int[] rotLeft(int[] a, int d) {
    if (a == null || a.length <= 1)
        return Arrays.copyOf(a, a.length); // nothing to rotate
    int shift = (d % a.length + a.length) % a.length; // normalize d
    if (shift == 0)
        return Arrays.copyOf(a, a.length); // no or full rotation(s)
    int[] t = new int[a.length];
    System.arraycopy(a, shift, t, 0, a.length - shift);
    System.arraycopy(a, 0, t, a.length - shift, shift);
    return t;
}

Both of the above solution allow d to exceed the size of the array, i.e. do more than a full rotation, and to use negative values, i.e. rotate right instead of left.

Test

System.out.println(Arrays.toString(rotLeft(new int[] { 1, 2, 3, 4, 5 }, 1)));
System.out.println(Arrays.toString(rotLeft(new int[] { 1, 2, 3, 4, 5 }, 3)));
System.out.println(Arrays.toString(rotLeft(new int[] { 1, 2, 3, 4, 5 }, 5)));
System.out.println(Arrays.toString(rotLeft(new int[] { 1, 2, 3, 4, 5 }, 7)));
System.out.println(Arrays.toString(rotLeft(new int[] { 1, 2, 3, 4, 5 }, -7)));

Output

[2, 3, 4, 5, 1]
[4, 5, 1, 2, 3]
[1, 2, 3, 4, 5]
[3, 4, 5, 1, 2]
[4, 5, 1, 2, 3]

You don't have to do the rotations one by one. If you rotate by d, the element at index i moves to index i - d when i >= d, and into index N + i - d when i < d. Makes sense?

int[] result = new int[a.length]
for (int i = 0; i < a.length; i++) {
    if (i < d) {
        result[a.length + i - d] = a[i];
    } else {
        result[i - d] = a[i];
    }
}
return result;

To handle the case where d >= a.length, you can add d = d % a.length as a pre-processing step.