Bi Directional Circular Arrays Algorithm without pointers

Question

I have an array of the 26 English alphabet characters. Say:

char a[26] = ['a','b','c','d'.......so on till ....'z']

I am required to move the elements in the array in a circular manner (could be clockwise or anticlockwise).

I understand that there exist a data structure known as a Circular Array but it is unidirectional.

Say, I want to move each element in the array ahead by 3 elements then by new array should be:

char new[26] = ['x','y','z','a','b'... and so on till 'w']

But, I may also want to shift the elements backwards by say 2 elements, then my new array should be:

char new[26]=['c','d','e'....and so on... 'y','z','a','b']

All this should be done without using pointers (because I haven't read about pointers yet).

Is there a method to implement this?

I have searched a lot about circular arrays but I never realized how simple arrays can be used as circular arrays and have movement of elements both forward and backward. Can someone tell me if there is a method to do this?

The array size is fixed.

We are coding in C

Answer 1

You simply use modulus on the array index:

size_t index;
size_t move_index(int pos_or_neg_steps) {
    return (index + pos_or_neg_steps) % 26;
}

Answer 2

Naively with O(1) additional memory and in O(n^2) time

C Code (naive):

void shiftElements(int *array, int size, int shift) {
  int i,reverse;

  reverse = shift < 0;
  if(shift < 0)
    shift = -shift;
  if(shift > size) 
    shift %= size;

  for(i=0; i < shift; ++i) {
    if(reverse)
      shiftForward(array,size);
    else
      shiftBackwards(array,size);
  }
}

void shiftForward(int *array, int size) {
  int tmp = array[size-1];
  int i;
  for(i=size; i>0; --i)
    array[i] = array[i-1]; 
  array[0] = tmp;
}

void shiftBackward(int *array, int size) {
  int tmp = array[0];
  int i;
  for(i=0; i<size; ++i)
    array[i] = array[i+1]; 
  array[size-1] = tmp;
}

Efficiently with O(N) additional memory and in O(N) time

C Code (efficient):

void shiftElements(int *array, int size, int shift) {
  int i,reverse,absVal,*tmp;

  reverse = shift < 0;
  absVal  = shift < 0 ? -shift : shift;
  if(shift > size) 
    shift %= size;
  *tmp = malloc(shift * sizeof *array);

  for(i=0; i < absVal; ++i)
    tmp[i] = array[size-shift+i];

  for(i=0; i < size; ++i)
    array[(i+shift)%size] = array[i];

  for(i=0; i < absVal; ++i)
    array[size+shift+i] = tmp[i];
  free(tmp);
} // I still need to test some corner cases, but you should get the idea